Nemcio/SCM-Manager
1
0
Fork 0
mirror of https://github.com/scm-manager/scm-manager.git synced 2025-11-14 17:26:22 +01:00
Code Issues Packages Projects Releases Activity

use reflow to migrate from flow to typescript

Browse Source
This commit is contained in:
Sebastian Sdorra
2019-10-19 16:38:07 +02:00
parent f7b8050dfa
commit 6e7a08a3bb
495 changed files with 14239 additions and 13766 deletions
Download Patch File Download Diff File Expand all files Collapse all files

783
scm-ui/ui-webapp/src/repos/permissions/modules/permissions.test.js
View File

@@ -1,783 +0,0 @@
// @flow
import configureMockStore from "redux-mock-store";
import thunk from "redux-thunk";
import fetchMock from "fetch-mock";
import reducer, {
CREATE_PERMISSION,
CREATE_PERMISSION_FAILURE,
CREATE_PERMISSION_PENDING,
CREATE_PERMISSION_SUCCESS,
createPermission,
createPermissionSuccess,
DELETE_PERMISSION,
DELETE_PERMISSION_FAILURE,
DELETE_PERMISSION_PENDING,
DELETE_PERMISSION_SUCCESS,
deletePermission,
deletePermissionSuccess,
FETCH_PERMISSIONS,
FETCH_PERMISSIONS_FAILURE,
FETCH_PERMISSIONS_PENDING,
FETCH_PERMISSIONS_SUCCESS,
fetchPermissions,
fetchPermissionsSuccess,
getCreatePermissionFailure,
getDeletePermissionFailure,
getDeletePermissionsFailure,
getFetchPermissionsFailure,
getModifyPermissionFailure,
getModifyPermissionsFailure,
getPermissionsOfRepo,
hasCreatePermission,
isCreatePermissionPending,
isDeletePermissionPending,
isFetchPermissionsPending,
isModifyPermissionPending,
MODIFY_PERMISSION,
MODIFY_PERMISSION_FAILURE,
MODIFY_PERMISSION_PENDING,
MODIFY_PERMISSION_SUCCESS,
modifyPermission,
modifyPermissionSuccess
} from "./permissions";
import type {Permission, PermissionCollection} from "@scm-manager/ui-types";
const hitchhiker_puzzle42Permission_user_eins: Permission = {
name: "user_eins",
type: "READ",
groupPermission: false,
_links: {
self: {
href:
"http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_eins"
},
delete: {
href:
"http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_eins"
},
update: {
href:
"http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_eins"
}
},
verbs: []
};
const hitchhiker_puzzle42Permission_user_zwei: Permission = {
name: "user_zwei",
type: "WRITE",
groupPermission: true,
_links: {
self: {
href:
"http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_zwei"
},
delete: {
href:
"http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_zwei"
},
update: {
href:
"http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_zwei"
}
},
verbs: []
};
const hitchhiker_puzzle42Permissions: PermissionCollection = [
hitchhiker_puzzle42Permission_user_eins,
hitchhiker_puzzle42Permission_user_zwei
];
const hitchhiker_puzzle42RepoPermissions = {
_embedded: {
permissions: hitchhiker_puzzle42Permissions
},
_links: {
create: {
href:
"http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions"
}
}
};
describe("permission fetch", () => {
const REPOS_URL = "/api/v2/repositories";
const URL = "repositories";
const mockStore = configureMockStore([thunk]);
afterEach(() => {
fetchMock.reset();
fetchMock.restore();
});
it("should successfully fetch permissions to repo hitchhiker/puzzle42", () => {
fetchMock.getOnce(
REPOS_URL + "/hitchhiker/puzzle42/permissions",
hitchhiker_puzzle42RepoPermissions
);
const expectedActions = [
{
type: FETCH_PERMISSIONS_PENDING,
payload: {
namespace: "hitchhiker",
repoName: "puzzle42"
},
itemId: "hitchhiker/puzzle42"
},
{
type: FETCH_PERMISSIONS_SUCCESS,
payload: hitchhiker_puzzle42RepoPermissions,
itemId: "hitchhiker/puzzle42"
}
];
const store = mockStore({});
return store
.dispatch(
fetchPermissions(
URL + "/hitchhiker/puzzle42/permissions",
"hitchhiker",
"puzzle42"
)
)
.then(() => {
expect(store.getActions()).toEqual(expectedActions);
});
});
it("should dispatch FETCH_PERMISSIONS_FAILURE, it the request fails", () => {
fetchMock.getOnce(REPOS_URL + "/hitchhiker/puzzle42/permissions", {
status: 500
});
const store = mockStore({});
return store
.dispatch(
fetchPermissions(
URL + "/hitchhiker/puzzle42/permissions",
"hitchhiker",
"puzzle42"
)
)
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(FETCH_PERMISSIONS_PENDING);
expect(actions[1].type).toEqual(FETCH_PERMISSIONS_FAILURE);
expect(actions[1].payload).toBeDefined();
});
});
it("should successfully modify user_eins permission", () => {
fetchMock.putOnce(
hitchhiker_puzzle42Permission_user_eins._links.update.href,
{
status: 204
}
);
let editedPermission = { ...hitchhiker_puzzle42Permission_user_eins, type: "OWNER" };
const store = mockStore({});
return store
.dispatch(modifyPermission(editedPermission, "hitchhiker", "puzzle42"))
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(MODIFY_PERMISSION_PENDING);
expect(actions[1].type).toEqual(MODIFY_PERMISSION_SUCCESS);
});
});
it("should successfully modify user_eins permission and call the callback", () => {
fetchMock.putOnce(
hitchhiker_puzzle42Permission_user_eins._links.update.href,
{
status: 204
}
);
let editedPermission = { ...hitchhiker_puzzle42Permission_user_eins, type: "OWNER" };
const store = mockStore({});
let called = false;
const callback = () => {
called = true;
};
return store
.dispatch(
modifyPermission(editedPermission, "hitchhiker", "puzzle42", callback)
)
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(MODIFY_PERMISSION_PENDING);
expect(actions[1].type).toEqual(MODIFY_PERMISSION_SUCCESS);
expect(called).toBe(true);
});
});
it("should fail modifying on HTTP 500", () => {
fetchMock.putOnce(
hitchhiker_puzzle42Permission_user_eins._links.update.href,
{
status: 500
}
);
let editedPermission = { ...hitchhiker_puzzle42Permission_user_eins, type: "OWNER" };
const store = mockStore({});
return store
.dispatch(modifyPermission(editedPermission, "hitchhiker", "puzzle42"))
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(MODIFY_PERMISSION_PENDING);
expect(actions[1].type).toEqual(MODIFY_PERMISSION_FAILURE);
expect(actions[1].payload).toBeDefined();
});
});
it("should add a permission successfully", () => {
// unmatched
fetchMock.postOnce(REPOS_URL + "/hitchhiker/puzzle42/permissions", {
status: 204,
headers: {
location: "repositories/hitchhiker/puzzle42/permissions/user_eins"
}
});
fetchMock.getOnce(
REPOS_URL + "/hitchhiker/puzzle42/permissions/user_eins",
hitchhiker_puzzle42Permission_user_eins
);
const store = mockStore({});
return store
.dispatch(
createPermission(
URL + "/hitchhiker/puzzle42/permissions",
hitchhiker_puzzle42Permission_user_eins,
"hitchhiker",
"puzzle42"
)
)
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(CREATE_PERMISSION_PENDING);
expect(actions[1].type).toEqual(CREATE_PERMISSION_SUCCESS);
});
});
it("should fail adding a permission on HTTP 500", () => {
fetchMock.postOnce(REPOS_URL + "/hitchhiker/puzzle42/permissions", {
status: 500
});
const store = mockStore({});
return store
.dispatch(
createPermission(
URL + "/hitchhiker/puzzle42/permissions",
hitchhiker_puzzle42Permission_user_eins,
"hitchhiker",
"puzzle42"
)
)
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(CREATE_PERMISSION_PENDING);
expect(actions[1].type).toEqual(CREATE_PERMISSION_FAILURE);
expect(actions[1].payload).toBeDefined();
});
});
it("should call the callback after permission successfully created", () => {
// unmatched
fetchMock.postOnce(REPOS_URL + "/hitchhiker/puzzle42/permissions", {
status: 204,
headers: {
location: "repositories/hitchhiker/puzzle42/permissions/user_eins"
}
});
fetchMock.getOnce(
REPOS_URL + "/hitchhiker/puzzle42/permissions/user_eins",
hitchhiker_puzzle42Permission_user_eins
);
let callMe = "not yet";
const callback = () => {
callMe = "yeah";
};
const store = mockStore({});
return store
.dispatch(
createPermission(
URL + "/hitchhiker/puzzle42/permissions",
hitchhiker_puzzle42Permission_user_eins,
"hitchhiker",
"puzzle42",
callback
)
)
.then(() => {
expect(callMe).toBe("yeah");
});
});
it("should delete successfully permission user_eins", () => {
fetchMock.deleteOnce(
hitchhiker_puzzle42Permission_user_eins._links.delete.href,
{
status: 204
}
);
const store = mockStore({});
return store
.dispatch(
deletePermission(
hitchhiker_puzzle42Permission_user_eins,
"hitchhiker",
"puzzle42"
)
)
.then(() => {
const actions = store.getActions();
expect(actions.length).toBe(2);
expect(actions[0].type).toEqual(DELETE_PERMISSION_PENDING);
expect(actions[0].payload).toBe(
hitchhiker_puzzle42Permission_user_eins
);
expect(actions[1].type).toEqual(DELETE_PERMISSION_SUCCESS);
});
});
it("should call the callback, after successful delete", () => {
fetchMock.deleteOnce(
hitchhiker_puzzle42Permission_user_eins._links.delete.href,
{
status: 204
}
);
let called = false;
const callMe = () => {
called = true;
};
const store = mockStore({});
return store
.dispatch(
deletePermission(
hitchhiker_puzzle42Permission_user_eins,
"hitchhiker",
"puzzle42",
callMe
)
)
.then(() => {
expect(called).toBeTruthy();
});
});
it("should fail to delete permission", () => {
fetchMock.deleteOnce(
hitchhiker_puzzle42Permission_user_eins._links.delete.href,
{
status: 500
}
);
const store = mockStore({});
return store
.dispatch(
deletePermission(
hitchhiker_puzzle42Permission_user_eins,
"hitchhiker",
"puzzle42"
)
)
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(DELETE_PERMISSION_PENDING);
expect(actions[0].payload).toBe(
hitchhiker_puzzle42Permission_user_eins
);
expect(actions[1].type).toEqual(DELETE_PERMISSION_FAILURE);
expect(actions[1].payload).toBeDefined();
});
});
});
describe("permissions reducer", () => {
it("should return empty object, if state and action is undefined", () => {
expect(reducer()).toEqual({});
});
it("should return the same state, if the action is undefined", () => {
const state = { x: true };
expect(reducer(state)).toBe(state);
});
it("should return the same state, if the action is unknown to the reducer", () => {
const state = { x: true };
expect(reducer(state, { type: "EL_SPECIALE" })).toBe(state);
});
it("should store the permissions on FETCH_PERMISSION_SUCCESS", () => {
const newState = reducer(
{},
fetchPermissionsSuccess(
hitchhiker_puzzle42RepoPermissions,
"hitchhiker",
"puzzle42"
)
);
expect(newState["hitchhiker/puzzle42"].entries).toBe(
hitchhiker_puzzle42Permissions
);
});
it("should update permission", () => {
const oldState = {
"hitchhiker/puzzle42": {
entries: [hitchhiker_puzzle42Permission_user_eins]
}
};
let permissionEdited = { ...hitchhiker_puzzle42Permission_user_eins, type: "OWNER" };
let expectedState = {
"hitchhiker/puzzle42": {
entries: [permissionEdited]
}
};
const newState = reducer(
oldState,
modifyPermissionSuccess(permissionEdited, "hitchhiker", "puzzle42")
);
expect(newState["hitchhiker/puzzle42"]).toEqual(
expectedState["hitchhiker/puzzle42"]
);
});
it("should remove permission from state when delete succeeds", () => {
const state = {
"hitchhiker/puzzle42": {
entries: [
hitchhiker_puzzle42Permission_user_eins,
hitchhiker_puzzle42Permission_user_zwei
]
}
};
const expectedState = {
"hitchhiker/puzzle42": {
entries: [hitchhiker_puzzle42Permission_user_zwei]
}
};
const newState = reducer(
state,
deletePermissionSuccess(
hitchhiker_puzzle42Permission_user_eins,
"hitchhiker",
"puzzle42"
)
);
expect(newState["hitchhiker/puzzle42"]).toEqual(
expectedState["hitchhiker/puzzle42"]
);
});
it("should add permission", () => {
//changing state had to be removed because of errors
const oldState = {
"hitchhiker/puzzle42": {
entries: [hitchhiker_puzzle42Permission_user_eins]
}
};
let expectedState = {
"hitchhiker/puzzle42": {
entries: [
hitchhiker_puzzle42Permission_user_eins,
hitchhiker_puzzle42Permission_user_zwei
]
}
};
const newState = reducer(
oldState,
createPermissionSuccess(
hitchhiker_puzzle42Permission_user_zwei,
"hitchhiker",
"puzzle42"
)
);
expect(newState["hitchhiker/puzzle42"]).toEqual(
expectedState["hitchhiker/puzzle42"]
);
});
});
describe("permissions selectors", () => {
const error = new Error("something goes wrong");
it("should return the permissions of one repository", () => {
const state = {
permissions: {
"hitchhiker/puzzle42": {
entries: hitchhiker_puzzle42Permissions
}
}
};
const repoPermissions = getPermissionsOfRepo(
state,
"hitchhiker",
"puzzle42"
);
expect(repoPermissions).toEqual(hitchhiker_puzzle42Permissions);
});
it("should return true, when fetch permissions is pending", () => {
const state = {
pending: {
[FETCH_PERMISSIONS + "/hitchhiker/puzzle42"]: true
}
};
expect(isFetchPermissionsPending(state, "hitchhiker", "puzzle42")).toEqual(
true
);
});
it("should return false, when fetch permissions is not pending", () => {
expect(isFetchPermissionsPending({}, "hitchiker", "puzzle42")).toEqual(
false
);
});
it("should return error when fetch permissions did fail", () => {
const state = {
failure: {
[FETCH_PERMISSIONS + "/hitchhiker/puzzle42"]: error
}
};
expect(getFetchPermissionsFailure(state, "hitchhiker", "puzzle42")).toEqual(
error
);
});
it("should return undefined when fetch permissions did not fail", () => {
expect(getFetchPermissionsFailure({}, "hitchhiker", "puzzle42")).toBe(
undefined
);
});
it("should return true, when modify permission is pending", () => {
const state = {
pending: {
[MODIFY_PERMISSION + "/hitchhiker/puzzle42/user_eins"]: true
}
};
expect(
isModifyPermissionPending(
state,
"hitchhiker",
"puzzle42",
hitchhiker_puzzle42Permission_user_eins
)
).toEqual(true);
});
it("should return false, when modify permission is not pending", () => {
expect(
isModifyPermissionPending(
{},
"hitchiker",
"puzzle42",
hitchhiker_puzzle42Permission_user_eins
)
).toEqual(false);
});
it("should return error when modify permission did fail", () => {
const state = {
failure: {
[MODIFY_PERMISSION + "/hitchhiker/puzzle42/user_eins"]: error
}
};
expect(
getModifyPermissionFailure(
state,
"hitchhiker",
"puzzle42",
hitchhiker_puzzle42Permission_user_eins
)
).toEqual(error);
});
it("should return undefined when modify permission did not fail", () => {
expect(
getModifyPermissionFailure(
{},
"hitchhiker",
"puzzle42",
hitchhiker_puzzle42Permission_user_eins
)
).toBe(undefined);
});
it("should return error when one of the modify permissions did fail", () => {
const state = {
permissions: {
"hitchhiker/puzzle42": { entries: hitchhiker_puzzle42Permissions }
},
failure: {
[MODIFY_PERMISSION + "/hitchhiker/puzzle42/user_eins"]: error
}
};
expect(
getModifyPermissionsFailure(state, "hitchhiker", "puzzle42")
).toEqual(error);
});
it("should return undefined when no modify permissions did not fail", () => {
expect(getModifyPermissionsFailure({}, "hitchhiker", "puzzle42")).toBe(
undefined
);
});
it("should return true, when createPermission is true", () => {
const state = {
permissions: {
"hitchhiker/puzzle42": {
createPermission: true
}
}
};
expect(hasCreatePermission(state, "hitchhiker", "puzzle42")).toBe(true);
});
it("should return false, when createPermission is false", () => {
const state = {
permissions: {
"hitchhiker/puzzle42": {
createPermission: false
}
}
};
expect(hasCreatePermission(state, "hitchhiker", "puzzle42")).toEqual(false);
});
it("should return true, when delete permission is pending", () => {
const state = {
pending: {
[DELETE_PERMISSION + "/hitchhiker/puzzle42/user_eins"]: true
}
};
expect(
isDeletePermissionPending(
state,
"hitchhiker",
"puzzle42",
hitchhiker_puzzle42Permission_user_eins
)
).toEqual(true);
});
it("should return false, when delete permission is not pending", () => {
expect(
isDeletePermissionPending(
{},
"hitchiker",
"puzzle42",
hitchhiker_puzzle42Permission_user_eins
)
).toEqual(false);
});
it("should return error when delete permission did fail", () => {
const state = {
failure: {
[DELETE_PERMISSION + "/hitchhiker/puzzle42/user_eins"]: error
}
};
expect(
getDeletePermissionFailure(
state,
"hitchhiker",
"puzzle42",
hitchhiker_puzzle42Permission_user_eins
)
).toEqual(error);
});
it("should return undefined when delete permission did not fail", () => {
expect(
getDeletePermissionFailure(
{},
"hitchhiker",
"puzzle42",
hitchhiker_puzzle42Permission_user_eins
)
).toBe(undefined);
});
it("should return error when one of the delete permissions did fail", () => {
const state = {
permissions: {
"hitchhiker/puzzle42": { entries: hitchhiker_puzzle42Permissions }
},
failure: {
[DELETE_PERMISSION + "/hitchhiker/puzzle42/user_eins"]: error
}
};
expect(
getDeletePermissionsFailure(state, "hitchhiker", "puzzle42")
).toEqual(error);
});
it("should return undefined when no delete permissions did not fail", () => {
expect(getDeletePermissionsFailure({}, "hitchhiker", "puzzle42")).toBe(
undefined
);
});
it("should return true, when create permission is pending", () => {
const state = {
pending: {
[CREATE_PERMISSION + "/hitchhiker/puzzle42"]: true
}
};
expect(isCreatePermissionPending(state, "hitchhiker", "puzzle42")).toEqual(
true
);
});
it("should return false, when create permissions is not pending", () => {
expect(isCreatePermissionPending({}, "hitchiker", "puzzle42")).toEqual(
false
);
});
it("should return error when create permissions did fail", () => {
const state = {
failure: {
[CREATE_PERMISSION + "/hitchhiker/puzzle42"]: error
}
};
expect(getCreatePermissionFailure(state, "hitchhiker", "puzzle42")).toEqual(
error
);
});
it("should return undefined when create permissions did not fail", () => {
expect(getCreatePermissionFailure({}, "hitchhiker", "puzzle42")).toBe(
undefined
);
});
});

806
scm-ui/ui-webapp/src/repos/permissions/modules/permissions.test.ts Normal file
View File

@@ -0,0 +1,806 @@
import configureMockStore from 'redux-mock-store';
import thunk from 'redux-thunk';
import fetchMock from 'fetch-mock';
import reducer, {
CREATE_PERMISSION,
CREATE_PERMISSION_FAILURE,
CREATE_PERMISSION_PENDING,
CREATE_PERMISSION_SUCCESS,
createPermission,
createPermissionSuccess,
DELETE_PERMISSION,
DELETE_PERMISSION_FAILURE,
DELETE_PERMISSION_PENDING,
DELETE_PERMISSION_SUCCESS,
deletePermission,
deletePermissionSuccess,
FETCH_PERMISSIONS,
FETCH_PERMISSIONS_FAILURE,
FETCH_PERMISSIONS_PENDING,
FETCH_PERMISSIONS_SUCCESS,
fetchPermissions,
fetchPermissionsSuccess,
getCreatePermissionFailure,
getDeletePermissionFailure,
getDeletePermissionsFailure,
getFetchPermissionsFailure,
getModifyPermissionFailure,
getModifyPermissionsFailure,
getPermissionsOfRepo,
hasCreatePermission,
isCreatePermissionPending,
isDeletePermissionPending,
isFetchPermissionsPending,
isModifyPermissionPending,
MODIFY_PERMISSION,
MODIFY_PERMISSION_FAILURE,
MODIFY_PERMISSION_PENDING,
MODIFY_PERMISSION_SUCCESS,
modifyPermission,
modifyPermissionSuccess,
} from './permissions';
import { Permission, PermissionCollection } from '@scm-manager/ui-types';
const hitchhiker_puzzle42Permission_user_eins: Permission = {
name: 'user_eins',
type: 'READ',
groupPermission: false,
_links: {
self: {
href:
'http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_eins',
},
delete: {
href:
'http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_eins',
},
update: {
href:
'http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_eins',
},
},
verbs: [],
};
const hitchhiker_puzzle42Permission_user_zwei: Permission = {
name: 'user_zwei',
type: 'WRITE',
groupPermission: true,
_links: {
self: {
href:
'http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_zwei',
},
delete: {
href:
'http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_zwei',
},
update: {
href:
'http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions/user_zwei',
},
},
verbs: [],
};
const hitchhiker_puzzle42Permissions: PermissionCollection = [
hitchhiker_puzzle42Permission_user_eins,
hitchhiker_puzzle42Permission_user_zwei,
];
const hitchhiker_puzzle42RepoPermissions = {
_embedded: {
permissions: hitchhiker_puzzle42Permissions,
},
_links: {
create: {
href:
'http://localhost:8081/scm/api/rest/v2/repositories/hitchhiker/puzzle42/permissions',
},
},
};
describe('permission fetch', () => {
const REPOS_URL = '/api/v2/repositories';
const URL = 'repositories';
const mockStore = configureMockStore([thunk]);
afterEach(() => {
fetchMock.reset();
fetchMock.restore();
});
it('should successfully fetch permissions to repo hitchhiker/puzzle42', () => {
fetchMock.getOnce(
REPOS_URL + '/hitchhiker/puzzle42/permissions',
hitchhiker_puzzle42RepoPermissions,
);
const expectedActions = [
{
type: FETCH_PERMISSIONS_PENDING,
payload: {
namespace: 'hitchhiker',
repoName: 'puzzle42',
},
itemId: 'hitchhiker/puzzle42',
},
{
type: FETCH_PERMISSIONS_SUCCESS,
payload: hitchhiker_puzzle42RepoPermissions,
itemId: 'hitchhiker/puzzle42',
},
];
const store = mockStore({});
return store
.dispatch(
fetchPermissions(
URL + '/hitchhiker/puzzle42/permissions',
'hitchhiker',
'puzzle42',
),
)
.then(() => {
expect(store.getActions()).toEqual(expectedActions);
});
});
it('should dispatch FETCH_PERMISSIONS_FAILURE, it the request fails', () => {
fetchMock.getOnce(REPOS_URL + '/hitchhiker/puzzle42/permissions', {
status: 500,
});
const store = mockStore({});
return store
.dispatch(
fetchPermissions(
URL + '/hitchhiker/puzzle42/permissions',
'hitchhiker',
'puzzle42',
),
)
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(FETCH_PERMISSIONS_PENDING);
expect(actions[1].type).toEqual(FETCH_PERMISSIONS_FAILURE);
expect(actions[1].payload).toBeDefined();
});
});
it('should successfully modify user_eins permission', () => {
fetchMock.putOnce(
hitchhiker_puzzle42Permission_user_eins._links.update.href,
{
status: 204,
},
);
let editedPermission = {
...hitchhiker_puzzle42Permission_user_eins,
type: 'OWNER',
};
const store = mockStore({});
return store
.dispatch(modifyPermission(editedPermission, 'hitchhiker', 'puzzle42'))
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(MODIFY_PERMISSION_PENDING);
expect(actions[1].type).toEqual(MODIFY_PERMISSION_SUCCESS);
});
});
it('should successfully modify user_eins permission and call the callback', () => {
fetchMock.putOnce(
hitchhiker_puzzle42Permission_user_eins._links.update.href,
{
status: 204,
},
);
let editedPermission = {
...hitchhiker_puzzle42Permission_user_eins,
type: 'OWNER',
};
const store = mockStore({});
let called = false;
const callback = () => {
called = true;
};
return store
.dispatch(
modifyPermission(editedPermission, 'hitchhiker', 'puzzle42', callback),
)
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(MODIFY_PERMISSION_PENDING);
expect(actions[1].type).toEqual(MODIFY_PERMISSION_SUCCESS);
expect(called).toBe(true);
});
});
it('should fail modifying on HTTP 500', () => {
fetchMock.putOnce(
hitchhiker_puzzle42Permission_user_eins._links.update.href,
{
status: 500,
},
);
let editedPermission = {
...hitchhiker_puzzle42Permission_user_eins,
type: 'OWNER',
};
const store = mockStore({});
return store
.dispatch(modifyPermission(editedPermission, 'hitchhiker', 'puzzle42'))
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(MODIFY_PERMISSION_PENDING);
expect(actions[1].type).toEqual(MODIFY_PERMISSION_FAILURE);
expect(actions[1].payload).toBeDefined();
});
});
it('should add a permission successfully', () => {
// unmatched
fetchMock.postOnce(REPOS_URL + '/hitchhiker/puzzle42/permissions', {
status: 204,
headers: {
location: 'repositories/hitchhiker/puzzle42/permissions/user_eins',
},
});
fetchMock.getOnce(
REPOS_URL + '/hitchhiker/puzzle42/permissions/user_eins',
hitchhiker_puzzle42Permission_user_eins,
);
const store = mockStore({});
return store
.dispatch(
createPermission(
URL + '/hitchhiker/puzzle42/permissions',
hitchhiker_puzzle42Permission_user_eins,
'hitchhiker',
'puzzle42',
),
)
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(CREATE_PERMISSION_PENDING);
expect(actions[1].type).toEqual(CREATE_PERMISSION_SUCCESS);
});
});
it('should fail adding a permission on HTTP 500', () => {
fetchMock.postOnce(REPOS_URL + '/hitchhiker/puzzle42/permissions', {
status: 500,
});
const store = mockStore({});
return store
.dispatch(
createPermission(
URL + '/hitchhiker/puzzle42/permissions',
hitchhiker_puzzle42Permission_user_eins,
'hitchhiker',
'puzzle42',
),
)
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(CREATE_PERMISSION_PENDING);
expect(actions[1].type).toEqual(CREATE_PERMISSION_FAILURE);
expect(actions[1].payload).toBeDefined();
});
});
it('should call the callback after permission successfully created', () => {
// unmatched
fetchMock.postOnce(REPOS_URL + '/hitchhiker/puzzle42/permissions', {
status: 204,
headers: {
location: 'repositories/hitchhiker/puzzle42/permissions/user_eins',
},
});
fetchMock.getOnce(
REPOS_URL + '/hitchhiker/puzzle42/permissions/user_eins',
hitchhiker_puzzle42Permission_user_eins,
);
let callMe = 'not yet';
const callback = () => {
callMe = 'yeah';
};
const store = mockStore({});
return store
.dispatch(
createPermission(
URL + '/hitchhiker/puzzle42/permissions',
hitchhiker_puzzle42Permission_user_eins,
'hitchhiker',
'puzzle42',
callback,
),
)
.then(() => {
expect(callMe).toBe('yeah');
});
});
it('should delete successfully permission user_eins', () => {
fetchMock.deleteOnce(
hitchhiker_puzzle42Permission_user_eins._links.delete.href,
{
status: 204,
},
);
const store = mockStore({});
return store
.dispatch(
deletePermission(
hitchhiker_puzzle42Permission_user_eins,
'hitchhiker',
'puzzle42',
),
)
.then(() => {
const actions = store.getActions();
expect(actions.length).toBe(2);
expect(actions[0].type).toEqual(DELETE_PERMISSION_PENDING);
expect(actions[0].payload).toBe(
hitchhiker_puzzle42Permission_user_eins,
);
expect(actions[1].type).toEqual(DELETE_PERMISSION_SUCCESS);
});
});
it('should call the callback, after successful delete', () => {
fetchMock.deleteOnce(
hitchhiker_puzzle42Permission_user_eins._links.delete.href,
{
status: 204,
},
);
let called = false;
const callMe = () => {
called = true;
};
const store = mockStore({});
return store
.dispatch(
deletePermission(
hitchhiker_puzzle42Permission_user_eins,
'hitchhiker',
'puzzle42',
callMe,
),
)
.then(() => {
expect(called).toBeTruthy();
});
});
it('should fail to delete permission', () => {
fetchMock.deleteOnce(
hitchhiker_puzzle42Permission_user_eins._links.delete.href,
{
status: 500,
},
);
const store = mockStore({});
return store
.dispatch(
deletePermission(
hitchhiker_puzzle42Permission_user_eins,
'hitchhiker',
'puzzle42',
),
)
.then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(DELETE_PERMISSION_PENDING);
expect(actions[0].payload).toBe(
hitchhiker_puzzle42Permission_user_eins,
);
expect(actions[1].type).toEqual(DELETE_PERMISSION_FAILURE);
expect(actions[1].payload).toBeDefined();
});
});
});
describe('permissions reducer', () => {
it('should return empty object, if state and action is undefined', () => {
expect(reducer()).toEqual({});
});
it('should return the same state, if the action is undefined', () => {
const state = {
x: true,
};
expect(reducer(state)).toBe(state);
});
it('should return the same state, if the action is unknown to the reducer', () => {
const state = {
x: true,
};
expect(
reducer(state, {
type: 'EL_SPECIALE',
}),
).toBe(state);
});
it('should store the permissions on FETCH_PERMISSION_SUCCESS', () => {
const newState = reducer(
{},
fetchPermissionsSuccess(
hitchhiker_puzzle42RepoPermissions,
'hitchhiker',
'puzzle42',
),
);
expect(newState['hitchhiker/puzzle42'].entries).toBe(
hitchhiker_puzzle42Permissions,
);
});
it('should update permission', () => {
const oldState = {
'hitchhiker/puzzle42': {
entries: [hitchhiker_puzzle42Permission_user_eins],
},
};
let permissionEdited = {
...hitchhiker_puzzle42Permission_user_eins,
type: 'OWNER',
};
let expectedState = {
'hitchhiker/puzzle42': {
entries: [permissionEdited],
},
};
const newState = reducer(
oldState,
modifyPermissionSuccess(permissionEdited, 'hitchhiker', 'puzzle42'),
);
expect(newState['hitchhiker/puzzle42']).toEqual(
expectedState['hitchhiker/puzzle42'],
);
});
it('should remove permission from state when delete succeeds', () => {
const state = {
'hitchhiker/puzzle42': {
entries: [
hitchhiker_puzzle42Permission_user_eins,
hitchhiker_puzzle42Permission_user_zwei,
],
},
};
const expectedState = {
'hitchhiker/puzzle42': {
entries: [hitchhiker_puzzle42Permission_user_zwei],
},
};
const newState = reducer(
state,
deletePermissionSuccess(
hitchhiker_puzzle42Permission_user_eins,
'hitchhiker',
'puzzle42',
),
);
expect(newState['hitchhiker/puzzle42']).toEqual(
expectedState['hitchhiker/puzzle42'],
);
});
it('should add permission', () => {
//changing state had to be removed because of errors
const oldState = {
'hitchhiker/puzzle42': {
entries: [hitchhiker_puzzle42Permission_user_eins],
},
};
let expectedState = {
'hitchhiker/puzzle42': {
entries: [
hitchhiker_puzzle42Permission_user_eins,
hitchhiker_puzzle42Permission_user_zwei,
],
},
};
const newState = reducer(
oldState,
createPermissionSuccess(
hitchhiker_puzzle42Permission_user_zwei,
'hitchhiker',
'puzzle42',
),
);
expect(newState['hitchhiker/puzzle42']).toEqual(
expectedState['hitchhiker/puzzle42'],
);
});
});
describe('permissions selectors', () => {
const error = new Error('something goes wrong');
it('should return the permissions of one repository', () => {
const state = {
permissions: {
'hitchhiker/puzzle42': {
entries: hitchhiker_puzzle42Permissions,
},
},
};
const repoPermissions = getPermissionsOfRepo(
state,
'hitchhiker',
'puzzle42',
);
expect(repoPermissions).toEqual(hitchhiker_puzzle42Permissions);
});
it('should return true, when fetch permissions is pending', () => {
const state = {
pending: {
[FETCH_PERMISSIONS + '/hitchhiker/puzzle42']: true,
},
};
expect(isFetchPermissionsPending(state, 'hitchhiker', 'puzzle42')).toEqual(
true,
);
});
it('should return false, when fetch permissions is not pending', () => {
expect(isFetchPermissionsPending({}, 'hitchiker', 'puzzle42')).toEqual(
false,
);
});
it('should return error when fetch permissions did fail', () => {
const state = {
failure: {
[FETCH_PERMISSIONS + '/hitchhiker/puzzle42']: error,
},
};
expect(getFetchPermissionsFailure(state, 'hitchhiker', 'puzzle42')).toEqual(
error,
);
});
it('should return undefined when fetch permissions did not fail', () => {
expect(getFetchPermissionsFailure({}, 'hitchhiker', 'puzzle42')).toBe(
undefined,
);
});
it('should return true, when modify permission is pending', () => {
const state = {
pending: {
[MODIFY_PERMISSION + '/hitchhiker/puzzle42/user_eins']: true,
},
};
expect(
isModifyPermissionPending(
state,
'hitchhiker',
'puzzle42',
hitchhiker_puzzle42Permission_user_eins,
),
).toEqual(true);
});
it('should return false, when modify permission is not pending', () => {
expect(
isModifyPermissionPending(
{},
'hitchiker',
'puzzle42',
hitchhiker_puzzle42Permission_user_eins,
),
).toEqual(false);
});
it('should return error when modify permission did fail', () => {
const state = {
failure: {
[MODIFY_PERMISSION + '/hitchhiker/puzzle42/user_eins']: error,
},
};
expect(
getModifyPermissionFailure(
state,
'hitchhiker',
'puzzle42',
hitchhiker_puzzle42Permission_user_eins,
),
).toEqual(error);
});
it('should return undefined when modify permission did not fail', () => {
expect(
getModifyPermissionFailure(
{},
'hitchhiker',
'puzzle42',
hitchhiker_puzzle42Permission_user_eins,
),
).toBe(undefined);
});
it('should return error when one of the modify permissions did fail', () => {
const state = {
permissions: {
'hitchhiker/puzzle42': {
entries: hitchhiker_puzzle42Permissions,
},
},
failure: {
[MODIFY_PERMISSION + '/hitchhiker/puzzle42/user_eins']: error,
},
};
expect(
getModifyPermissionsFailure(state, 'hitchhiker', 'puzzle42'),
).toEqual(error);
});
it('should return undefined when no modify permissions did not fail', () => {
expect(getModifyPermissionsFailure({}, 'hitchhiker', 'puzzle42')).toBe(
undefined,
);
});
it('should return true, when createPermission is true', () => {
const state = {
permissions: {
'hitchhiker/puzzle42': {
createPermission: true,
},
},
};
expect(hasCreatePermission(state, 'hitchhiker', 'puzzle42')).toBe(true);
});
it('should return false, when createPermission is false', () => {
const state = {
permissions: {
'hitchhiker/puzzle42': {
createPermission: false,
},
},
};
expect(hasCreatePermission(state, 'hitchhiker', 'puzzle42')).toEqual(false);
});
it('should return true, when delete permission is pending', () => {
const state = {
pending: {
[DELETE_PERMISSION + '/hitchhiker/puzzle42/user_eins']: true,
},
};
expect(
isDeletePermissionPending(
state,
'hitchhiker',
'puzzle42',
hitchhiker_puzzle42Permission_user_eins,
),
).toEqual(true);
});
it('should return false, when delete permission is not pending', () => {
expect(
isDeletePermissionPending(
{},
'hitchiker',
'puzzle42',
hitchhiker_puzzle42Permission_user_eins,
),
).toEqual(false);
});
it('should return error when delete permission did fail', () => {
const state = {
failure: {
[DELETE_PERMISSION + '/hitchhiker/puzzle42/user_eins']: error,
},
};
expect(
getDeletePermissionFailure(
state,
'hitchhiker',
'puzzle42',
hitchhiker_puzzle42Permission_user_eins,
),
).toEqual(error);
});
it('should return undefined when delete permission did not fail', () => {
expect(
getDeletePermissionFailure(
{},
'hitchhiker',
'puzzle42',
hitchhiker_puzzle42Permission_user_eins,
),
).toBe(undefined);
});
it('should return error when one of the delete permissions did fail', () => {
const state = {
permissions: {
'hitchhiker/puzzle42': {
entries: hitchhiker_puzzle42Permissions,
},
},
failure: {
[DELETE_PERMISSION + '/hitchhiker/puzzle42/user_eins']: error,
},
};
expect(
getDeletePermissionsFailure(state, 'hitchhiker', 'puzzle42'),
).toEqual(error);
});
it('should return undefined when no delete permissions did not fail', () => {
expect(getDeletePermissionsFailure({}, 'hitchhiker', 'puzzle42')).toBe(
undefined,
);
});
it('should return true, when create permission is pending', () => {
const state = {
pending: {
[CREATE_PERMISSION + '/hitchhiker/puzzle42']: true,
},
};
expect(isCreatePermissionPending(state, 'hitchhiker', 'puzzle42')).toEqual(
true,
);
});
it('should return false, when create permissions is not pending', () => {
expect(isCreatePermissionPending({}, 'hitchiker', 'puzzle42')).toEqual(
false,
);
});
it('should return error when create permissions did fail', () => {
const state = {
failure: {
[CREATE_PERMISSION + '/hitchhiker/puzzle42']: error,
},
};
expect(getCreatePermissionFailure(state, 'hitchhiker', 'puzzle42')).toEqual(
error,
);
});
it('should return undefined when create permissions did not fail', () => {
expect(getCreatePermissionFailure({}, 'hitchhiker', 'puzzle42')).toBe(
undefined,
);
});
});

361
scm-ui/ui-webapp/src/repos/permissions/modules/permissions.js → scm-ui/ui-webapp/src/repos/permissions/modules/permissions.ts
View File

@@ -1,93 +1,55 @@
// @flow
import type { Action } from "@scm-manager/ui-components";
import { apiClient } from "@scm-manager/ui-components";
import * as types from "../../../modules/types";
import type {
import { Action } from '@scm-manager/ui-components';
import { apiClient } from '@scm-manager/ui-components';
import * as types from '../../../modules/types';
import {
RepositoryRole,
Permission,
PermissionCollection,
PermissionCreateEntry
} from "@scm-manager/ui-types";
import { isPending } from "../../../modules/pending";
import { getFailure } from "../../../modules/failure";
import { Dispatch } from "redux";
PermissionCreateEntry,
} from '@scm-manager/ui-types';
import { isPending } from '../../../modules/pending';
import { getFailure } from '../../../modules/failure';
import { Dispatch } from 'redux';
export const FETCH_AVAILABLE = "scm/permissions/FETCH_AVAILABLE";
export const FETCH_AVAILABLE_PENDING = `${FETCH_AVAILABLE}_${
types.PENDING_SUFFIX
}`;
export const FETCH_AVAILABLE_SUCCESS = `${FETCH_AVAILABLE}_${
types.SUCCESS_SUFFIX
}`;
export const FETCH_AVAILABLE_FAILURE = `${FETCH_AVAILABLE}_${
types.FAILURE_SUFFIX
}`;
export const FETCH_PERMISSIONS = "scm/permissions/FETCH_PERMISSIONS";
export const FETCH_PERMISSIONS_PENDING = `${FETCH_PERMISSIONS}_${
types.PENDING_SUFFIX
}`;
export const FETCH_PERMISSIONS_SUCCESS = `${FETCH_PERMISSIONS}_${
types.SUCCESS_SUFFIX
}`;
export const FETCH_PERMISSIONS_FAILURE = `${FETCH_PERMISSIONS}_${
types.FAILURE_SUFFIX
}`;
export const MODIFY_PERMISSION = "scm/permissions/MODFIY_PERMISSION";
export const MODIFY_PERMISSION_PENDING = `${MODIFY_PERMISSION}_${
types.PENDING_SUFFIX
}`;
export const MODIFY_PERMISSION_SUCCESS = `${MODIFY_PERMISSION}_${
types.SUCCESS_SUFFIX
}`;
export const MODIFY_PERMISSION_FAILURE = `${MODIFY_PERMISSION}_${
types.FAILURE_SUFFIX
}`;
export const MODIFY_PERMISSION_RESET = `${MODIFY_PERMISSION}_${
types.RESET_SUFFIX
}`;
export const CREATE_PERMISSION = "scm/permissions/CREATE_PERMISSION";
export const CREATE_PERMISSION_PENDING = `${CREATE_PERMISSION}_${
types.PENDING_SUFFIX
}`;
export const CREATE_PERMISSION_SUCCESS = `${CREATE_PERMISSION}_${
types.SUCCESS_SUFFIX
}`;
export const CREATE_PERMISSION_FAILURE = `${CREATE_PERMISSION}_${
types.FAILURE_SUFFIX
}`;
export const CREATE_PERMISSION_RESET = `${CREATE_PERMISSION}_${
types.RESET_SUFFIX
}`;
export const DELETE_PERMISSION = "scm/permissions/DELETE_PERMISSION";
export const DELETE_PERMISSION_PENDING = `${DELETE_PERMISSION}_${
types.PENDING_SUFFIX
}`;
export const DELETE_PERMISSION_SUCCESS = `${DELETE_PERMISSION}_${
types.SUCCESS_SUFFIX
}`;
export const DELETE_PERMISSION_FAILURE = `${DELETE_PERMISSION}_${
types.FAILURE_SUFFIX
}`;
export const DELETE_PERMISSION_RESET = `${DELETE_PERMISSION}_${
types.RESET_SUFFIX
}`;
export const FETCH_AVAILABLE = 'scm/permissions/FETCH_AVAILABLE';
export const FETCH_AVAILABLE_PENDING = `${FETCH_AVAILABLE}_${types.PENDING_SUFFIX}`;
export const FETCH_AVAILABLE_SUCCESS = `${FETCH_AVAILABLE}_${types.SUCCESS_SUFFIX}`;
export const FETCH_AVAILABLE_FAILURE = `${FETCH_AVAILABLE}_${types.FAILURE_SUFFIX}`;
export const FETCH_PERMISSIONS = 'scm/permissions/FETCH_PERMISSIONS';
export const FETCH_PERMISSIONS_PENDING = `${FETCH_PERMISSIONS}_${types.PENDING_SUFFIX}`;
export const FETCH_PERMISSIONS_SUCCESS = `${FETCH_PERMISSIONS}_${types.SUCCESS_SUFFIX}`;
export const FETCH_PERMISSIONS_FAILURE = `${FETCH_PERMISSIONS}_${types.FAILURE_SUFFIX}`;
export const MODIFY_PERMISSION = 'scm/permissions/MODFIY_PERMISSION';
export const MODIFY_PERMISSION_PENDING = `${MODIFY_PERMISSION}_${types.PENDING_SUFFIX}`;
export const MODIFY_PERMISSION_SUCCESS = `${MODIFY_PERMISSION}_${types.SUCCESS_SUFFIX}`;
export const MODIFY_PERMISSION_FAILURE = `${MODIFY_PERMISSION}_${types.FAILURE_SUFFIX}`;
export const MODIFY_PERMISSION_RESET = `${MODIFY_PERMISSION}_${types.RESET_SUFFIX}`;
export const CREATE_PERMISSION = 'scm/permissions/CREATE_PERMISSION';
export const CREATE_PERMISSION_PENDING = `${CREATE_PERMISSION}_${types.PENDING_SUFFIX}`;
export const CREATE_PERMISSION_SUCCESS = `${CREATE_PERMISSION}_${types.SUCCESS_SUFFIX}`;
export const CREATE_PERMISSION_FAILURE = `${CREATE_PERMISSION}_${types.FAILURE_SUFFIX}`;
export const CREATE_PERMISSION_RESET = `${CREATE_PERMISSION}_${types.RESET_SUFFIX}`;
export const DELETE_PERMISSION = 'scm/permissions/DELETE_PERMISSION';
export const DELETE_PERMISSION_PENDING = `${DELETE_PERMISSION}_${types.PENDING_SUFFIX}`;
export const DELETE_PERMISSION_SUCCESS = `${DELETE_PERMISSION}_${types.SUCCESS_SUFFIX}`;
export const DELETE_PERMISSION_FAILURE = `${DELETE_PERMISSION}_${types.FAILURE_SUFFIX}`;
export const DELETE_PERMISSION_RESET = `${DELETE_PERMISSION}_${types.RESET_SUFFIX}`;
const CONTENT_TYPE = "application/vnd.scmm-repositoryPermission+json";
const CONTENT_TYPE = 'application/vnd.scmm-repositoryPermission+json';
// fetch available permissions
export function fetchAvailablePermissionsIfNeeded(
repositoryRolesLink: string,
repositoryVerbsLink: string
repositoryVerbsLink: string,
) {
return function(dispatch: any, getState: () => Object) {
return function(dispatch: any, getState: () => object) {
if (shouldFetchAvailablePermissions(getState())) {
return fetchAvailablePermissions(
dispatch,
getState,
repositoryRolesLink,
repositoryVerbsLink
repositoryVerbsLink,
);
}
};
@@ -95,9 +57,9 @@ export function fetchAvailablePermissionsIfNeeded(
export function fetchAvailablePermissions(
dispatch: any,
getState: () => Object,
getState: () => object,
repositoryRolesLink: string,
repositoryVerbsLink: string
repositoryVerbsLink: string,
) {
dispatch(fetchAvailablePending());
return apiClient
@@ -112,7 +74,7 @@ export function fetchAvailablePermissions(
.then(repositoryVerbs => {
return {
repositoryVerbs,
repositoryRoles
repositoryRoles,
};
});
})
@@ -124,7 +86,7 @@ export function fetchAvailablePermissions(
});
}
export function shouldFetchAvailablePermissions(state: Object) {
export function shouldFetchAvailablePermissions(state: object) {
if (
isFetchAvailablePermissionsPending(state) ||
getFetchAvailablePermissionsFailure(state)
@@ -138,17 +100,17 @@ export function fetchAvailablePending(): Action {
return {
type: FETCH_AVAILABLE_PENDING,
payload: {},
itemId: "available"
itemId: 'available',
};
}
export function fetchAvailableSuccess(
available: [RepositoryRole[], string[]]
available: [RepositoryRole[], string[]],
): Action {
return {
type: FETCH_AVAILABLE_SUCCESS,
payload: available,
itemId: "available"
itemId: 'available',
};
}
@@ -156,9 +118,9 @@ export function fetchAvailableFailure(error: Error): Action {
return {
type: FETCH_AVAILABLE_FAILURE,
payload: {
error
error,
},
itemId: "available"
itemId: 'available',
};
}
@@ -167,7 +129,7 @@ export function fetchAvailableFailure(error: Error): Action {
export function fetchPermissions(
link: string,
namespace: string,
repoName: string
repoName: string,
) {
return function(dispatch: any) {
dispatch(fetchPermissionsPending(namespace, repoName));
@@ -185,43 +147,43 @@ export function fetchPermissions(
export function fetchPermissionsPending(
namespace: string,
repoName: string
repoName: string,
): Action {
return {
type: FETCH_PERMISSIONS_PENDING,
payload: {
namespace,
repoName
repoName,
},
itemId: namespace + "/" + repoName
itemId: namespace + '/' + repoName,
};
}
export function fetchPermissionsSuccess(
permissions: any,
namespace: string,
repoName: string
repoName: string,
): Action {
return {
type: FETCH_PERMISSIONS_SUCCESS,
payload: permissions,
itemId: namespace + "/" + repoName
itemId: namespace + '/' + repoName,
};
}
export function fetchPermissionsFailure(
namespace: string,
repoName: string,
error: Error
error: Error,
): Action {
return {
type: FETCH_PERMISSIONS_FAILURE,
payload: {
namespace,
repoName,
error
error,
},
itemId: namespace + "/" + repoName
itemId: namespace + '/' + repoName,
};
}
@@ -231,7 +193,7 @@ export function modifyPermission(
permission: Permission,
namespace: string,
repoName: string,
callback?: () => void
callback?: () => void,
) {
return function(dispatch: any) {
dispatch(modifyPermissionPending(permission, namespace, repoName));
@@ -252,27 +214,27 @@ export function modifyPermission(
export function modifyPermissionPending(
permission: Permission,
namespace: string,
repoName: string
repoName: string,
): Action {
return {
type: MODIFY_PERMISSION_PENDING,
payload: permission,
itemId: createItemId(permission, namespace, repoName)
itemId: createItemId(permission, namespace, repoName),
};
}
export function modifyPermissionSuccess(
permission: Permission,
namespace: string,
repoName: string
repoName: string,
): Action {
return {
type: MODIFY_PERMISSION_SUCCESS,
payload: {
permission,
position: namespace + "/" + repoName
position: namespace + '/' + repoName,
},
itemId: createItemId(permission, namespace, repoName)
itemId: createItemId(permission, namespace, repoName),
};
}
@@ -280,18 +242,21 @@ export function modifyPermissionFailure(
permission: Permission,
error: Error,
namespace: string,
repoName: string
repoName: string,
): Action {
return {
type: MODIFY_PERMISSION_FAILURE,
payload: { error, permission },
itemId: createItemId(permission, namespace, repoName)
payload: {
error,
permission,
},
itemId: createItemId(permission, namespace, repoName),
};
}
function newPermissions(
oldPermissions: PermissionCollection,
newPermission: Permission
newPermission: Permission,
) {
for (let i = 0; i < oldPermissions.length; i++) {
if (oldPermissions[i].name === newPermission.name) {
@@ -306,9 +271,9 @@ export function modifyPermissionReset(namespace: string, repoName: string) {
type: MODIFY_PERMISSION_RESET,
payload: {
namespace,
repoName
repoName,
},
itemId: namespace + "/" + repoName
itemId: namespace + '/' + repoName,
};
}
@@ -318,27 +283,27 @@ export function createPermission(
permission: PermissionCreateEntry,
namespace: string,
repoName: string,
callback?: () => void
callback?: () => void,
) {
return function(dispatch: Dispatch) {
dispatch(createPermissionPending(permission, namespace, repoName));
return apiClient
.post(link, permission, CONTENT_TYPE)
.then(response => {
const location = response.headers.get("Location");
const location = response.headers.get('Location');
return apiClient.get(location);
})
.then(response => response.json())
.then(createdPermission => {
dispatch(
createPermissionSuccess(createdPermission, namespace, repoName)
createPermissionSuccess(createdPermission, namespace, repoName),
);
if (callback) {
callback();
}
})
.catch(err =>
dispatch(createPermissionFailure(err, namespace, repoName))
dispatch(createPermissionFailure(err, namespace, repoName)),
);
};
}
@@ -346,46 +311,46 @@ export function createPermission(
export function createPermissionPending(
permission: PermissionCreateEntry,
namespace: string,
repoName: string
repoName: string,
): Action {
return {
type: CREATE_PERMISSION_PENDING,
payload: permission,
itemId: namespace + "/" + repoName
itemId: namespace + '/' + repoName,
};
}
export function createPermissionSuccess(
permission: PermissionCreateEntry,
namespace: string,
repoName: string
repoName: string,
): Action {
return {
type: CREATE_PERMISSION_SUCCESS,
payload: {
permission,
position: namespace + "/" + repoName
position: namespace + '/' + repoName,
},
itemId: namespace + "/" + repoName
itemId: namespace + '/' + repoName,
};
}
export function createPermissionFailure(
error: Error,
namespace: string,
repoName: string
repoName: string,
): Action {
return {
type: CREATE_PERMISSION_FAILURE,
payload: error,
itemId: namespace + "/" + repoName
itemId: namespace + '/' + repoName,
};
}
export function createPermissionReset(namespace: string, repoName: string) {
return {
type: CREATE_PERMISSION_RESET,
itemId: namespace + "/" + repoName
itemId: namespace + '/' + repoName,
};
}
@@ -395,7 +360,7 @@ export function deletePermission(
permission: Permission,
namespace: string,
repoName: string,
callback?: () => void
callback?: () => void,
) {
return function(dispatch: any) {
dispatch(deletePermissionPending(permission, namespace, repoName));
@@ -416,27 +381,27 @@ export function deletePermission(
export function deletePermissionPending(
permission: Permission,
namespace: string,
repoName: string
repoName: string,
): Action {
return {
type: DELETE_PERMISSION_PENDING,
payload: permission,
itemId: createItemId(permission, namespace, repoName)
itemId: createItemId(permission, namespace, repoName),
};
}
export function deletePermissionSuccess(
permission: Permission,
namespace: string,
repoName: string
repoName: string,
): Action {
return {
type: DELETE_PERMISSION_SUCCESS,
payload: {
permission,
position: namespace + "/" + repoName
position: namespace + '/' + repoName,
},
itemId: createItemId(permission, namespace, repoName)
itemId: createItemId(permission, namespace, repoName),
};
}
@@ -444,15 +409,15 @@ export function deletePermissionFailure(
permission: Permission,
namespace: string,
repoName: string,
error: Error
error: Error,
): Action {
return {
type: DELETE_PERMISSION_FAILURE,
payload: {
error,
permission
permission,
},
itemId: createItemId(permission, namespace, repoName)
itemId: createItemId(permission, namespace, repoName),
};
}
@@ -461,15 +426,15 @@ export function deletePermissionReset(namespace: string, repoName: string) {
type: DELETE_PERMISSION_RESET,
payload: {
namespace,
repoName
repoName,
},
itemId: namespace + "/" + repoName
itemId: namespace + '/' + repoName,
};
}
function deletePermissionFromState(
oldPermissions: PermissionCollection,
permission: Permission
permission: Permission,
) {
let newPermission = [];
for (let i = 0; i < oldPermissions.length; i++) {
@@ -486,17 +451,19 @@ function deletePermissionFromState(
function createItemId(
permission: Permission,
namespace: string,
repoName: string
repoName: string,
) {
let groupPermission = permission.groupPermission ? "@" : "";
return namespace + "/" + repoName + "/" + groupPermission + permission.name;
let groupPermission = permission.groupPermission ? '@' : '';
return namespace + '/' + repoName + '/' + groupPermission + permission.name;
}
// reducer
export default function reducer(
state: Object = {},
action: Action = { type: "UNKNOWN" }
): Object {
state: object = {},
action: Action = {
type: 'UNKNOWN',
},
): object {
if (!action.payload) {
return state;
}
@@ -504,28 +471,28 @@ export default function reducer(
case FETCH_AVAILABLE_SUCCESS:
return {
...state,
available: action.payload
available: action.payload,
};
case FETCH_PERMISSIONS_SUCCESS:
return {
...state,
[action.itemId]: {
entries: action.payload._embedded.permissions,
createPermission: !!action.payload._links.create
}
createPermission: !!action.payload._links.create,
},
};
case MODIFY_PERMISSION_SUCCESS:
const positionOfPermission = action.payload.position;
const newPermission = newPermissions(
state[action.payload.position].entries,
action.payload.permission
action.payload.permission,
);
return {
...state,
[positionOfPermission]: {
...state[positionOfPermission],
entries: newPermission
}
entries: newPermission,
},
};
case CREATE_PERMISSION_SUCCESS:
// return state;
@@ -536,21 +503,21 @@ export default function reducer(
...state,
[position]: {
...state[position],
entries: permissions
}
entries: permissions,
},
};
case DELETE_PERMISSION_SUCCESS:
const permissionPosition = action.payload.position;
const new_Permissions = deletePermissionFromState(
state[action.payload.position].entries,
action.payload.permission
action.payload.permission,
);
return {
...state,
[permissionPosition]: {
...state[permissionPosition],
entries: new_Permissions
}
entries: new_Permissions,
},
};
default:
return state;
@@ -559,21 +526,21 @@ export default function reducer(
// selectors
export function getAvailablePermissions(state: Object) {
export function getAvailablePermissions(state: object) {
if (state.permissions) {
return state.permissions.available;
}
}
export function getAvailableRepositoryRoles(state: Object) {
export function getAvailableRepositoryRoles(state: object) {
return available(state).repositoryRoles;
}
export function getAvailableRepositoryVerbs(state: Object) {
export function getAvailableRepositoryVerbs(state: object) {
return available(state).repositoryVerbs;
}
function available(state: Object) {
function available(state: object) {
if (state.permissions && state.permissions.available) {
return state.permissions.available;
}
@@ -581,125 +548,125 @@ function available(state: Object) {
}
export function getPermissionsOfRepo(
state: Object,
state: object,
namespace: string,
repoName: string
repoName: string,
) {
if (state.permissions && state.permissions[namespace + "/" + repoName]) {
return state.permissions[namespace + "/" + repoName].entries;
if (state.permissions && state.permissions[namespace + '/' + repoName]) {
return state.permissions[namespace + '/' + repoName].entries;
}
}
export function isFetchAvailablePermissionsPending(state: Object) {
return isPending(state, FETCH_AVAILABLE, "available");
export function isFetchAvailablePermissionsPending(state: object) {
return isPending(state, FETCH_AVAILABLE, 'available');
}
export function isFetchPermissionsPending(
state: Object,
state: object,
namespace: string,
repoName: string
repoName: string,
) {
return isPending(state, FETCH_PERMISSIONS, namespace + "/" + repoName);
return isPending(state, FETCH_PERMISSIONS, namespace + '/' + repoName);
}
export function getFetchAvailablePermissionsFailure(state: Object) {
return getFailure(state, FETCH_AVAILABLE, "available");
export function getFetchAvailablePermissionsFailure(state: object) {
return getFailure(state, FETCH_AVAILABLE, 'available');
}
export function getFetchPermissionsFailure(
state: Object,
state: object,
namespace: string,
repoName: string
repoName: string,
) {
return getFailure(state, FETCH_PERMISSIONS, namespace + "/" + repoName);
return getFailure(state, FETCH_PERMISSIONS, namespace + '/' + repoName);
}
export function isModifyPermissionPending(
state: Object,
state: object,
namespace: string,
repoName: string,
permission: Permission
permission: Permission,
) {
return isPending(
state,
MODIFY_PERMISSION,
createItemId(permission, namespace, repoName)
createItemId(permission, namespace, repoName),
);
}
export function getModifyPermissionFailure(
state: Object,
state: object,
namespace: string,
repoName: string,
permission: Permission
permission: Permission,
) {
return getFailure(
state,
MODIFY_PERMISSION,
createItemId(permission, namespace, repoName)
createItemId(permission, namespace, repoName),
);
}
export function hasCreatePermission(
state: Object,
state: object,
namespace: string,
repoName: string
repoName: string,
) {
if (state.permissions && state.permissions[namespace + "/" + repoName])
return state.permissions[namespace + "/" + repoName].createPermission;
if (state.permissions && state.permissions[namespace + '/' + repoName])
return state.permissions[namespace + '/' + repoName].createPermission;
else return null;
}
export function isCreatePermissionPending(
state: Object,
state: object,
namespace: string,
repoName: string
repoName: string,
) {
return isPending(state, CREATE_PERMISSION, namespace + "/" + repoName);
return isPending(state, CREATE_PERMISSION, namespace + '/' + repoName);
}
export function getCreatePermissionFailure(
state: Object,
state: object,
namespace: string,
repoName: string
repoName: string,
) {
return getFailure(state, CREATE_PERMISSION, namespace + "/" + repoName);
return getFailure(state, CREATE_PERMISSION, namespace + '/' + repoName);
}
export function isDeletePermissionPending(
state: Object,
state: object,
namespace: string,
repoName: string,
permission: Permission
permission: Permission,
) {
return isPending(
state,
DELETE_PERMISSION,
createItemId(permission, namespace, repoName)
createItemId(permission, namespace, repoName),
);
}
export function getDeletePermissionFailure(
state: Object,
state: object,
namespace: string,
repoName: string,
permission: Permission
permission: Permission,
) {
return getFailure(
state,
DELETE_PERMISSION,
createItemId(permission, namespace, repoName)
createItemId(permission, namespace, repoName),
);
}
export function getDeletePermissionsFailure(
state: Object,
state: object,
namespace: string,
repoName: string
repoName: string,
) {
const permissions =
state.permissions && state.permissions[namespace + "/" + repoName]
? state.permissions[namespace + "/" + repoName].entries
state.permissions && state.permissions[namespace + '/' + repoName]
? state.permissions[namespace + '/' + repoName].entries
: null;
if (permissions == null) return undefined;
for (let i = 0; i < permissions.length; i++) {
@@ -709,7 +676,7 @@ export function getDeletePermissionsFailure(
return getFailure(
state,
DELETE_PERMISSION,
createItemId(permissions[i], namespace, repoName)
createItemId(permissions[i], namespace, repoName),
);
}
}
@@ -717,13 +684,13 @@ export function getDeletePermissionsFailure(
}
export function getModifyPermissionsFailure(
state: Object,
state: object,
namespace: string,
repoName: string
repoName: string,
) {
const permissions =
state.permissions && state.permissions[namespace + "/" + repoName]
? state.permissions[namespace + "/" + repoName].entries
state.permissions && state.permissions[namespace + '/' + repoName]
? state.permissions[namespace + '/' + repoName].entries
: null;
if (permissions == null) return undefined;
for (let i = 0; i < permissions.length; i++) {
@@ -733,7 +700,7 @@ export function getModifyPermissionsFailure(
return getFailure(
state,
MODIFY_PERMISSION,
createItemId(permissions[i], namespace, repoName)
createItemId(permissions[i], namespace, repoName),
);
}
}
@@ -742,10 +709,10 @@ export function getModifyPermissionsFailure(
export function findVerbsForRole(
availableRepositoryRoles: RepositoryRole[],
roleName: string
roleName: string,
) {
const matchingRole = availableRepositoryRoles.find(
role => roleName === role.name
role => roleName === role.name,
);
if (matchingRole) {
return matchingRole.verbs;