private static UpdateResult <T> Failure <T>(BackendlessResponse <T> parsed) where T : BaseModel
        {
            var result = new UpdateResult <T>();

            result.Failed(null, parsed.ToString());
            return(result);
        }
        private BackendlessResponse <TestModel> SetupSuccessfulPull(params TestModel[] contents)
        {
            var response = BackendlessResponse <TestModel> .Success(contents);

            _responseParser.ParseArray <TestModel>(Json).Returns(response);
            return(response);
        }
        private static UpdateResult <T> Success <T>(BackendlessResponse <T> parsed) where T : BaseModel
        {
            var result = new UpdateResult <T>();

            foreach (var item in parsed.Content)
            {
                result.Success(item, item.ObjectId);
            }

            return(result);
        }
Example #4
0
        private BackendlessResponse <Assessment> SetFailedDeletion(Assessment assessment, string errorMessage)
        {
            var url  = Connection.GenerateTableUrl <Assessment>(assessment.ObjectId);
            var json = assessment.ObjectId;

            _restServiceCaller.Delete(url, Arg.Any <Dictionary <string, string> >())
            .Returns(Task.FromResult(json));
            _jsonSerializer.AsDictionary(json)
            .Returns(new Dictionary <string, string>());
            var backendlessResponse = BackendlessResponse <Assessment> .Failed("123", errorMessage);

            _responseParser.Parse <Assessment>(json).Returns(backendlessResponse);
            return(backendlessResponse);
        }
        private void Persist <T>(BackendlessResponse <T> parsed) where T : BaseModel
        {
            var context = PersistenceContextFactory.CreateFor <T>();
            var all     = context.LoadAll()
                          .Where(i => !i.IsNew())
                          .ToDictionary(i => i.ObjectId);

            foreach (var item in parsed.Content)
            {
                context.Save(item);
                all.Remove(item.ObjectId);
            }

            foreach (var item in all.Values)
            {
                context.Purge(item.ObjectId);
            }
        }
        private Assessment SetupSuccessfulPost(Assessment localAssessment)
        {
            var clonedLocalAssessment = new Assessment {
                ObjectId = localAssessment.ObjectId
            };
            var savedAssessment = CreateSavedAssessment();
            var url             = Connection.GenerateTableUrl <Assessment>();

            _jsonSerializer.Clone(localAssessment).Returns(clonedLocalAssessment);
            var serializedObject = $"{savedAssessment.ObjectId}-serialized";

            _jsonSerializer.Serialize(clonedLocalAssessment).Returns(serializedObject);
            var jsonResponse = $"{savedAssessment.ObjectId}-response";

            _restServiceCaller.Post(url, Arg.Any <Dictionary <string, string> >(), serializedObject)
            .Returns(Task.FromResult(jsonResponse));
            _responseParser.Parse <Assessment>(jsonResponse).Returns(BackendlessResponse <Assessment> .Success(savedAssessment));
            return(savedAssessment);
        }
        private BackendlessResponse <Assessment> SetupFailedPost(Assessment localAssessment, string errorMessage)
        {
            var clonedLocalAssessment = new Assessment {
                ObjectId = localAssessment.ObjectId
            };
            var savedAssessment = CreateSavedAssessment();
            var url             = Connection.GenerateTableUrl <Assessment>();

            _jsonSerializer.Clone(localAssessment).Returns(clonedLocalAssessment);
            var serializedObject = $"{savedAssessment.ObjectId}-serialized";

            _jsonSerializer.Serialize(clonedLocalAssessment).Returns(serializedObject);
            var jsonResponse = $"{savedAssessment.ObjectId}-failedResponse";

            _restServiceCaller.Post(url, Arg.Any <Dictionary <string, string> >(), serializedObject)
            .Returns(Task.FromResult(jsonResponse));
            var backendlessResponse = BackendlessResponse <Assessment> .Failed("error", errorMessage);

            _responseParser.Parse <Assessment>(jsonResponse).Returns(backendlessResponse);
            return(backendlessResponse);
        }