Can time series models be applied to synthetic data I would like to know if time series necessarily have to contain real (measured) data or can it also contain synthetic data (e.g. from a simulation). Does it make sense to apply time series models, like MA or ARIMA on synthetic data?
I'd be happy if you would mind answering my question.
 A: From my experience, it is common to test methods with synthetic data. I think doing so allows one to really focus on the strengths and weaknesses of a model. Then it is another question whether or not those tests and the synthetic data reflect real world scenarios well enough to make the method actually useful. But it has been certainly done.
As a reference, I can provide "A note on the Mean Absolute Scaled Error" by Philip Hans Franses (link), but I'm sure there are plenty of similar papers.
A: Applying time series techniques to simulated data is quite common, and it can be very enlightening indeed.
For example: pick an ARIMA model of reasonable order with well-behaved parameters, simulate it and apply some kind of automatic ARIMA fitter to the simulated series (like forecast::auto.arima() in R). How often will the original model be recovered? Answer: surprisingly rarely. It's simulations like these, where you know the ground truth, that can teach you a lot of humility.
Then again, to be honest, if a paper only applies its new method to simulated data, but not to real time series, I tend to lose interest. It's very easy to tweak a simulation in a way that supports your pet theory. With real data, not so much. (Yes, we can select datasets and overfit to the holdout data.)
So: applying methods to simulated data should be part of every time series analyst's toolbox. Among other tools.

Let us look at a little example. We will simulate $n=200$ data points from an ARIMA(1,1,1) process, with an AR(1) coefficient of $\phi_1=0.5$, an MA(1) coefficient of $\theta_1=-0.3$ and the default noise of $\epsilon\sim N(0,1)$. We then apply auto.arima() to the simulated series and ask whether auto.arima() at least gets the order (1,1,1) right. We do this whole process 1,000 times:
require(forecast)
n_sims <- 1e3
n_obs <- 200
model_true <- list(ar=0.5,ma=-0.3,order=c(1,1,1))

correct <- rep(FALSE,n_sims)
pb <- winProgressBar(max=n_sims)
for ( ii in 1:n_sims ) {
    setWinProgressBar(pb,ii,paste(ii,"of",n_sims))
    set.seed(ii) # for reproducibility
    sim <- arima.sim(model=model_true,n=n_obs)
    model <- auto.arima(sim)
    correct[ii] <- isTRUE(all.equal(model$arma,c(1,1,0,0,1,1,0)))   
    # this corresponds to ARIMA(1,1,1), see ?arima
}
close(pb)
summary(correct)

It turns out that in just 105 cases did we even get the correct order. I think this teaches us something about the inherent difficulty in even identifying the correct ARIMA order.
Of course, if we increase the parameter values, reduce the noise or increase the length of the series, we would be right more often.
The next step would be not to pluck parameter values out of thin air, as I did here. Instead, we could take a time series that is "typical" for the application we have in mind. Fit an ARIMA model to it, and then use the fitted order, parameters and residual variance as inputs to this simulation, i.e., treat the fitted ARIMA model as if it were the true data generating process. You will still be surprised at how rarely such a ("realistic"!) DGP will actually be found by auto.arima(). (Which is the gold standard in ARIMA model fitting, I hasten to say.) And of course, you can do similar exercises with Exponential Smoothing and/or other time series methods.
And this is the reason why simulated series have their place in time series analysis.
