$scope.$watch('auth.user', function(user) {
$scope.user = _.cloneDeep(user);
});
const showDeleteInfo = (state = INITIAL_STATE, { viewpointId }) => {
const viewpointsMap = cloneDeep(state.viewpointsMap);
viewpointsMap[viewpointId].willBeRemoved = true;
return { ...state, viewpointsMap };
};
import: function(inputTemplate): ITemplate {
const _t = cloneDeep(this);
return _calcFromExistingTemplate(_t, inputTemplate);
},
.add<CropLiveSearchResult[]>("OF_SEARCH_RESULTS_OK", function(s, { payload }) {
let state = cloneDeep(s);
state.cropSearchResults = payload;
return state;
});
const updateViewpointSuccess = (state = INITIAL_STATE, { viewpoint }) => {
const viewpointsMap = cloneDeep(state.viewpointsMap);
viewpointsMap[viewpoint._id].name = viewpoint.name;
return { ...state, viewpointsMap };
};
reset() {
this.tenants = _.cloneDeep(this.initialTenants);
this.tenantsToCreate = [];
this.tenantsToUpdate = [];
}
.add<Plant>("DESTROY_PLANT_OK", function(s, { payload }) {
let state = cloneDeep(s);
let a = state.plants;
a.splice(a.indexOf(payload), 1);
return state;
})
function factory() {
return new PrepackagedFilesystemProvider(_.cloneDeep(blob));
}
describe('fetchMore on an observable query with connection', () => {
const query = gql`
query Comment($repoName: String!, $start: Int!, $limit: Int!) {
entry(repoFullName: $repoName, start: $start, limit: $limit)
@connection(key: "repoName") {
comments {
text
}
}
}
`;
const transformedQuery = gql`
query Comment($repoName: String!, $start: Int!, $limit: Int!) {
entry(repoFullName: $repoName, start: $start, limit: $limit) {
comments {
text
__typename
}
__typename
}
}
`;
const variables = {
repoName: 'org/repo',
start: 0,
limit: 10,
};
const variablesMore = assign({}, variables, { start: 10, limit: 10 });
const result: any = {
data: {
__typename: 'Query',
entry: {
__typename: 'Entry',
comments: [],
},
},
};
const resultMore = cloneDeep(result);
for (let i = 1; i <= 10; i++) {
result.data.entry.comments.push({
text: `comment ${i}`,
__typename: 'Comment',
});
}
for (let i = 11; i <= 20; i++) {
resultMore.data.entry.comments.push({
text: `comment ${i}`,
__typename: 'Comment',
});
}
let latestResult: any = null;
let client: ApolloClient;
let link: any;
let sub: any;
function setup(...mockedResponses: any[]) {
link = mockSingleLink(
{
request: {
query: transformedQuery,
variables,
},
result,
},
...mockedResponses,
);
client = new ApolloClient({
link,
cache: new InMemoryCache(),
});
const obsHandle = client.watchQuery<any>({
query,
variables,
});
sub = obsHandle.subscribe({
next(queryResult) {
// do nothing
latestResult = queryResult;
},
});
return Promise.resolve(obsHandle);
}
function unsetup() {
sub.unsubscribe();
sub = null;
}
it('fetchMore with connection results merging', () => {
latestResult = null;
return setup({
request: {
query: transformedQuery,
variables: variablesMore,
},
result: resultMore,
})
.then(watchedQuery => {
return watchedQuery.fetchMore({
variables: { start: 10 }, // rely on the fact that the original variables had limit: 10
updateQuery: (prev, options) => {
const state = cloneDeep(prev) as any;
state.entry.comments = [
...state.entry.comments,
...(options.fetchMoreResult as any).entry.comments,
];
return state;
},
});
})
.then(data => {
expect(data.data.entry.comments).toHaveLength(10); // this is the server result
expect(data.loading).toBe(false);
const comments = latestResult.data.entry.comments;
expect(comments).toHaveLength(20);
for (let i = 1; i <= 20; i++) {
expect(comments[i - 1].text).toBe(`comment ${i}`);
}
unsetup();
});
});
it('will set the network status to `fetchMore`', done => {
link = mockSingleLink(
{ request: { query: transformedQuery, variables }, result, delay: 5 },
{
request: { query: transformedQuery, variables: variablesMore },
result: resultMore,
delay: 5,
},
);
client = new ApolloClient({
link,
cache: new InMemoryCache(),
});
const observable = client.watchQuery({
query,
variables,
notifyOnNetworkStatusChange: true,
});
let count = 0;
observable.subscribe({
next: ({ data, networkStatus }) => {
switch (count++) {
case 0:
expect(networkStatus).toBe(NetworkStatus.ready);
expect((data as any).entry.comments.length).toBe(10);
observable.fetchMore({
variables: { start: 10 },
updateQuery: (prev, options) => {
const state = cloneDeep(prev) as any;
state.entry.comments = [
...state.entry.comments,
...(options.fetchMoreResult as any).entry.comments,
];
return state;
},
});
break;
case 1:
expect(networkStatus).toBe(NetworkStatus.fetchMore);
expect((data as any).entry.comments.length).toBe(10);
break;
case 2:
expect(networkStatus).toBe(NetworkStatus.ready);
expect((data as any).entry.comments.length).toBe(10);
break;
case 3:
expect(networkStatus).toBe(NetworkStatus.ready);
expect((data as any).entry.comments.length).toBe(20);
done();
break;
default:
done.fail(new Error('`next` called too many times'));
}
},
error: error => done.fail(error),
complete: () => done.fail(new Error('Should not have completed')),
});
});
it('will not get an error from `fetchMore` if thrown', done => {
const fetchMoreError = new Error('Uh, oh!');
link = mockSingleLink(
{ request: { query: transformedQuery, variables }, result, delay: 5 },
{
request: { query: transformedQuery, variables: variablesMore },
error: fetchMoreError,
delay: 5,
},
);
client = new ApolloClient({
link,
cache: new InMemoryCache(),
});
const observable = client.watchQuery({
query,
variables,
notifyOnNetworkStatusChange: true,
});
let count = 0;
observable.subscribe({
next: ({ data, networkStatus }) => {
switch (count++) {
case 0:
expect(networkStatus).toBe(NetworkStatus.ready);
expect((data as any).entry.comments.length).toBe(10);
observable
.fetchMore({
variables: { start: 10 },
updateQuery: (prev, options) => {
const state = cloneDeep(prev) as any;
state.entry.comments = [
...state.entry.comments,
...(options.fetchMoreResult as any).entry.comments,
];
return state;
},
})
.catch(e => {
expect(e.networkError).toBe(fetchMoreError);
});
break;
case 1:
expect(networkStatus).toBe(NetworkStatus.fetchMore);
expect((data as any).entry.comments.length).toBe(10);
break;
default:
expect(networkStatus).toBe(NetworkStatus.ready);
expect((data as any).entry.comments.length).toBe(10);
done();
}
},
error: () => {
done.fail(new Error('`error` called when it wasn’t supposed to be.'));
},
complete: () => {
done.fail(
new Error('`complete` called when it wasn’t supposed to be.'),
);
},
});
});
});
$scope.duplicate = variable => {
const clone = _.cloneDeep(variable.getSaveModel());
$scope.current = variableSrv.createVariableFromModel(clone);
$scope.current.name = 'copy_of_' + variable.name;
variableSrv.addVariable($scope.current);
};
