I have been trying to figure out what is going wrong here for some time now. I have created a mockJson adapter to intercept Ajax requests. I basically just call the success method inside my adapter instead of making an Ajax call. As you can see I am using mockJson to spoof some JSON data.

```
ctor.prototype.ajax = function (config) {

    var jqConfig = {
        type: config.type, 
        url: config.url,
        data: config.params || config.data,
        dataType: config.dataType,
        contentType: config.contentType,
        crossDomain: config.crossDomain
    }

    if (!core.isEmpty(this.defaultSettings)) {
        var compositeConfig = core.extend({}, this.defaultSettings);
        jqConfig = core.extend(compositeConfig, jqConfig);
    }

    jqConfig.success = function (data, textStatus, XHR) {

        var httpResponse = {
            data: data.results,
            //status: XHR.status,
            //getHeaders: getHeadersFn(XHR),
            config: config
        };
        config.success(httpResponse);
        //XHR.onreadystatechange = null;
        //XHR.abort = null;
    };
    jqConfig.error = function (XHR, textStatus, errorThrown) {
        var httpResponse = {
            data: XHR.responseText,
            status: XHR.status,
            getHeaders: getHeadersFn(XHR),
            error: errorThrown,
            config: config
        };
        config.error(httpResponse);
        XHR.onreadystatechange = null;
        XHR.abort = null;
    };

    jqConfig.success($.mockJSON.generateFromTemplate({
        "results|1-1": [{
            "id|+1": 1,
            "$type": "Campaign",
            "name": "Campaign Name",
            "startDate": "2013-12-03T00:00:00.000",
            "budget|1-3000": 1
        }]
    }), null, null);

};

```

This returns a single result right now for simplicity. Next I have a custom JsonResultsAdapter as well. This is to basically map the $type property to the meta information required for entity translation:

```
      function configureBreezeManager() {

        var jsonResultsAdapter = new breeze.JsonResultsAdapter({
            name: "mockJson",
            extractResults: function (json) {
                return json.results;
            },
            visitNode: function (node, mappingContext, nodeContext) {

                var entityType = node["$type"];

                return {
                    entityType: entityType
                };
            }
        });

        var dataService = new breeze.DataService({
            serviceName: config.remoteServiceName,
            jsonResultsAdapter: jsonResultsAdapter,
            hasServerMetadata: false // don't ask the server for metadata
        });

        var mgr = new breeze.EntityManager({ dataService: dataService });
        model.configureMetadataStore(mgr.metadataStore);

        //are we debugging? Lets use mockJson
        if (config.debugEnabled())
            breeze.config.initializeAdapterInstance("ajax", "mockJson", true);

        return mgr;
    }

```

Lastly, I have my metadata model object being created and called before my query :

```
    function configureMetadataStore(metadataStore) {

        addLookupTypes(metadataStore);
        addCampaignType(metadataStore);
        addMessageType(metadataStore);

        metadataStore.setEntityTypeForResourceName('Campaigns', 'Campaign');
        metadataStore.setEntityTypeForResourceName('Messages', 'Message');
        metadataStore.setEntityTypeForResourceName('Demos', 'Demo');

        referenceCheckValidator = createReferenceCheckValidator();
        Validator.register(referenceCheckValidator);

        log('Validators registered');
    }

        function addCampaignType(store) {
        store.addEntityType({
            shortName: "Campaign",
            namespace: "My.Models",
            dataProperties: {
                id: { dataType: DataType.Int32, isNullable: false, isPartOfKey: true },
                name: { dataType: DataType.String, maxLength: 30, isNullable: false }
            }
        });

        store.registerEntityTypeCtor("Campaign", null, campaignInitializer);
    }

    function campaignInitializer(campaign) {
        campaign.errorMessage = ko.observable();

        campaign.startDateFormatted = ko.computed(function () {
            return moment(campaign.startDate()).format("MM-DD-YYYY");
        });
    }

```

My query :

```
         var query = EntityQuery.from('Campaigns').
            select('id, name, startDate, budget')
            .orderBy(orderBy.campaign);

```

First off, I didn't think I would need a custom JsonResultsAdapter if I am basically spoofing data in the form of a normal WebApi response, but alas I set it up based on some StackOverflow posts. The problem I am having are the Entities being returned are not having the properties wrapped as knockout observables. Later code is failing because of this and I will not be able to utilize all the aspects of breeze without this happening. Any help here would be greatly appreciated!