descope 1.0.4

data/spec/lib.descope/api/v1/management/authz_spec.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Descope::Api::V1::Management::Authz do
+  before(:all) do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Descope::Api::V1::Management::Authz)
+    @instance = dummy_instance
+  end
+
+  context '.save_schema' do
+    it 'should respond to .save_schema' do
+      expect(@instance).to respond_to :authz_save_schema
+    end
+
+    it 'is expected to create or update ReBac schema' do
+      schema = {
+        name: 'name-of-schema',
+        namespaces: [
+          {
+            name: 'name-of-namespace',
+            relationDefinitions: [
+              {
+                name: 'name-of-relation-definition',
+                complexDefinition: {
+                  nType: 'child',
+                  expression: {
+                    neType: 'self'
+                  }
+                }
+              }
+            ]
+          }
+        ]
+      }
+      expect(@instance).to receive(:post).with(
+        AUTHZ_SCHEMA_SAVE,
+        {
+          schema: schema,
+          upgrade: true
+        }
+      )
+      expect do
+        @instance.authz_save_schema(schema: schema, upgrade: true)
+      end.not_to raise_error
+    end
+  end
+
+  context '.delete_schema' do
+    it 'should respond to .delete_schema' do
+      expect(@instance).to respond_to :authz_delete_schema
+    end
+
+    it 'is expected to delete the schema for the project which will also delete all relations' do
+      expect(@instance).to receive(:post).with(AUTHZ_SCHEMA_DELETE)
+      expect do
+        @instance.authz_delete_schema
+      end.not_to raise_error
+    end
+  end
+
+  context '.load_schema' do
+    it 'should respond to .load_schema' do
+      expect(@instance).to respond_to :authz_load_schema
+    end
+
+    it 'is expected to load the schema for the project' do
+      expect(@instance).to receive(:post).with(AUTHZ_SCHEMA_LOAD)
+      expect do
+        @instance.authz_load_schema
+      end.not_to raise_error
+    end
+  end
+
+  context '.save_namespace' do
+    it 'should respond to .save_namespace' do
+      expect(@instance).to respond_to :authz_save_namespace
+    end
+
+    it 'is expected to create or update the given namespace' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_NS_SAVE,
+        {
+          namespace: 'test-namespace',
+          oldName: 'old-namespace',
+          schemaName: 'schema-name'
+        }
+      )
+      expect do
+        @instance.authz_save_namespace(namespace: 'test-namespace', old_name: 'old-namespace', schema_name: 'schema-name')
+      end.not_to raise_error
+    end
+  end
+
+  context '.delete_namespace' do
+    it 'should respond to .delete_namespace' do
+      expect(@instance).to respond_to :authz_delete_namespace
+    end
+
+    it 'is expected to delete the given namespace' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_NS_DELETE,
+        {
+          name: 'test-namespace',
+          schemaName: 'schema-name'
+        }
+      )
+      expect do
+        @instance.authz_delete_namespace(name: 'test-namespace', schema_name: 'schema-name')
+      end.not_to raise_error
+    end
+  end
+
+  context '.save_relation_definition' do
+    it 'should respond to .save_relation_definition' do
+      expect(@instance).to respond_to :authz_save_relation_definition
+    end
+
+    it 'is expected to create or update the given relation definition' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_RD_SAVE,
+        {
+          relationDefinition: 'test-relation-definition',
+          namespace: 'test-namespace',
+          old_name: 'old-relation-definition',
+          schemaName: 'schema-name'
+        }
+      )
+      expect do
+        @instance.authz_save_relation_definition(
+          relation_definition: 'test-relation-definition',
+          namespace: 'test-namespace',
+          old_name: 'old-relation-definition',
+          schema_name: 'schema-name'
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.delete_relation_definition' do
+    it 'should respond to .delete_relation_definition' do
+      expect(@instance).to respond_to :authz_delete_relation_definition
+    end
+
+    it 'is expected to delete the given relation definition' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_RD_DELETE,
+        {
+          name: 'test-relation-definition',
+          namespace: 'test-namespace',
+          schemaName: 'schema-name'
+        }
+      )
+      expect do
+        @instance.authz_delete_relation_definition(
+          name: 'test-relation-definition',
+          namespace: 'test-namespace',
+          schema_name: 'schema-name'
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.create_relation' do
+    it 'should respond to .create_relation' do
+      expect(@instance).to respond_to :authz_create_relations
+    end
+
+    it 'is expected to create the given relation' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_RE_CREATE,
+        {
+          relations: 'test-relations'
+        }
+      )
+      expect do
+        @instance.authz_create_relations('test-relations')
+      end.not_to raise_error
+    end
+  end
+
+  context '.delete_relation' do
+    it 'should respond to .delete_relation' do
+      expect(@instance).to respond_to :authz_delete_relations
+    end
+
+    it 'is expected to delete the given relation' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_RE_DELETE,
+        { relations: [{ resource: 'some-note', relationDefinition: 'owner', namespace: 'note', target: 'some-user' }] }
+      )
+      expect do
+        @instance.authz_delete_relations(
+          [{ resource: 'some-note', relationDefinition: 'owner', namespace: 'note', target: 'some-user' }]
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.delete_relations_for_resources' do
+    it 'should respond to .delete_relations_for_resources' do
+      expect(@instance).to respond_to :authz_delete_relations_for_resources
+    end
+
+    it 'is expected to delete the given relations for resources' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_RE_DELETE_RESOURCES,
+        {
+          resources: 'test-resources'
+        }
+      )
+      expect do
+        @instance.authz_delete_relations_for_resources('test-resources')
+      end.not_to raise_error
+    end
+  end
+
+  context 'has_relations?' do
+    it 'should respond to .has_relations?' do
+      expect(@instance).to respond_to :authz_has_relations?
+    end
+
+    it 'is expected to return true if the given resource has relations' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_RE_HAS_RELATIONS,
+        {
+          relationQueries: ['some-query']
+        }
+      )
+      expect do
+        @instance.authz_has_relations?(['some-query'])
+      end.not_to raise_error
+    end
+  end
+
+  context 'who_can_access?' do
+    it 'should respond to .who_can_access?' do
+      expect(@instance).to respond_to :authz_who_can_access?
+    end
+
+    it 'is expected to return the list of targets who can access the given resource with the given RD' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_RE_WHO,
+        {
+          resource: 'test-resource',
+          relationDefinition: 'test-relation-definition',
+          namespace: 'test-namespace'
+        }
+      )
+      expect do
+        @instance.authz_who_can_access?(resource: 'test-resource', relation_definition: 'test-relation-definition',
+                                        namespace: 'test-namespace')
+      end.not_to raise_error
+    end
+  end
+
+  context 'resource_relations' do
+    it 'should respond to .resource_relations' do
+      expect(@instance).to respond_to :authz_resource_relations
+    end
+
+    it 'is expected to return the list of relations for the given resources' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_RE_RESOURCE,
+        {
+          resources: ['test-resources']
+        }
+      )
+      expect do
+        @instance.authz_resource_relations(resources: ['test-resources'])
+      end.not_to raise_error
+    end
+  end
+
+  context 'target_relations' do
+    it 'should respond to .target_relations' do
+      expect(@instance).to respond_to :authz_target_relations
+    end
+
+    it 'is expected to return the list of relations for the given targets' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_RE_TARGETS,
+        {
+          targets: ['test-targets']
+        }
+      )
+      expect do
+        @instance.authz_target_relations(targets: ['test-targets'])
+      end.not_to raise_error
+    end
+  end
+
+  context 'what_can_target_access?' do
+    let(:mock_response) do
+      {
+        'relations' => [
+          {
+            'relationDefinition' => 'test-relation-definition',
+            'namespace' => 'test-namespace',
+            'targets' => ['test-targets'],
+            'resources' => ['test-resources']
+          }
+        ]
+      }
+    end
+
+    before do
+      allow(@instance).to receive(:post).with(
+        AUTHZ_RE_TARGET_ALL,
+        {
+          target: 'test-target'
+        }
+      ).and_return(mock_response)
+    end
+
+    it 'should respond to .what_can_target_access?' do
+      expect(@instance).to respond_to :authz_what_can_target_access?
+    end
+
+    it 'is expected to return the list of relations for the given target' do
+      expect(@instance).to receive(:post).with(
+        AUTHZ_RE_TARGET_ALL,
+        {
+          target: 'test-target'
+        }
+      )
+      res = nil
+      expect do
+        res = @instance.authz_what_can_target_access?(target: 'test-target')
+      end.not_to raise_error
+      expect(res).to be_a(Array)
+      expect(res.size).to eq(1)
+    end
+  end
+end

data/spec/lib.descope/api/v1/management/flow_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Descope::Api::V1::Management::Flow do
+  before(:all) do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Descope::Api::V1::Management::Flow)
+    @instance = dummy_instance
+  end
+
+  context '.list_or_search_flows' do
+    it 'should respond to .list_or_search_flows' do
+      expect(@instance).to respond_to :list_or_search_flows
+    end
+
+    it 'is expected to get flows' do
+      expect(@instance).to receive(:post).with(FLOW_LIST_PATH, { ids: %w[123 456] })
+      expect { @instance.list_or_search_flows(%w[123 456]) }.not_to raise_error
+    end
+  end
+
+  context '.export_flow' do
+    it 'should respond to .export_flow' do
+      expect(@instance).to respond_to :export_flow
+    end
+
+    it 'is expected to export flow' do
+      expect(@instance).to receive(:post).with(FLOW_EXPORT_PATH, { flowId: '123' })
+      expect { @instance.export_flow('123') }.not_to raise_error
+    end
+  end
+
+  context '.import_flow' do
+    it 'should respond to .import_flow' do
+      expect(@instance).to respond_to :import_flow
+    end
+
+    it 'is expected to import flow' do
+      expect(@instance).to receive(:post).with(
+        FLOW_IMPORT_PATH, {
+          flowId: '123',
+          flow: 'flow',
+          screens: %w[sign_up sign_in]
+        }
+      )
+      expect do
+        @instance.import_flow(
+          flow_id: '123',
+          flow: 'flow',
+          screens: %w[sign_up sign_in]
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.export_theme' do
+    it 'should respond to .export_theme' do
+      expect(@instance).to respond_to :export_theme
+    end
+
+    it 'is expected to export theme' do
+      expect(@instance).to receive(:post).with(THEME_EXPORT_PATH)
+      expect { @instance.export_theme }.not_to raise_error
+    end
+  end
+
+  context '.import_theme' do
+    it 'should respond to .import_theme' do
+      expect(@instance).to respond_to :import_theme
+    end
+
+    it 'is expected to import theme' do
+      expect(@instance).to receive(:post).with(THEME_IMPORT_PATH, { theme: 'theme123' })
+      expect { @instance.import_theme('theme123') }.not_to raise_error
+    end
+  end
+end

data/spec/lib.descope/api/v1/management/password_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Descope::Api::V1::Management::Password do
+  before(:all) do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Descope::Api::V1::Management::Password)
+    @instance = dummy_instance
+  end
+
+  context '.get_password_settings' do
+    it 'should get password settings' do
+      expect(@instance).to receive(:get).with('/v1/mgmt/password/settings', { tenantId: 'tenant_id' })
+      @instance.get_password_settings('tenant_id')
+    end
+  end
+
+  context '.update_password_settings' do
+    it 'should update password settings' do
+      expect(@instance).to receive(:post).with('/v1/mgmt/password/settings', { 'minLength' => 10 })
+      @instance.update_password_settings({ min_length: 10 })
+    end
+  end
+end

data/spec/lib.descope/api/v1/management/permission_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Descope::Api::V1::Management::Permission do
+  before(:all) do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Descope::Api::V1::Management::Permission)
+    @instance = dummy_instance
+  end
+
+  context '.create_permission' do
+    it 'should respond to .create_permission' do
+      expect(@instance).to respond_to :create_permission
+    end
+
+    it 'is expected to create a new permission' do
+      expect(@instance).to receive(:post).with(
+        PERMISSION_CREATE_PATH, {
+          name: 'test',
+          description: 'test'
+        }
+      )
+      expect do
+        @instance.create_permission(
+          name: 'test',
+          description: 'test'
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.update_permission' do
+    it 'should respond to .update_permission' do
+      expect(@instance).to respond_to :update_permission
+    end
+
+    it 'is expected to update a permission' do
+      expect(@instance).to receive(:post).with(
+        PERMISSION_UPDATE_PATH, {
+          name: 'test',
+          newName: 'production',
+          description: 'test'
+        }
+      )
+      expect do
+        @instance.update_permission(
+          name: 'test',
+          new_name: 'production',
+          description: 'test'
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.delete_permission' do
+    it 'should respond to .delete_permission' do
+      expect(@instance).to respond_to :delete_permission
+    end
+
+    it 'is expected to delete a permission' do
+      expect(@instance).to receive(:post).with(
+        PERMISSION_DELETE_PATH, { name: 'test' }
+      )
+      expect do
+        @instance.delete_permission('test')
+      end.not_to raise_error
+    end
+  end
+
+  context '.load_all_permissions' do
+    it 'should respond to .load_all_permissions' do
+      expect(@instance).to respond_to :load_all_permissions
+    end
+
+    it 'is expected to delete a permission' do
+      expect(@instance).to receive(:get).with(PERMISSION_LOAD_ALL_PATH)
+      expect { @instance.load_all_permissions }.not_to raise_error
+    end
+  end
+end

data/spec/lib.descope/api/v1/management/project_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Descope::Api::V1::Management::Project do
+  before(:all) do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Descope::Api::V1::Management::Project)
+    @instance = dummy_instance
+  end
+
+  context '.rename_project' do
+    it 'should respond to .rename_project' do
+      expect(@instance).to respond_to :rename_project
+    end
+
+    it 'is expected to rename the current project' do
+      expect(@instance).to receive(:post).with(
+        PROJECT_UPDATE_NAME, { name: 'test' }
+      )
+      expect { @instance.rename_project('test') }.not_to raise_error
+    end
+  end
+
+  context '.export_project' do
+    it 'should respond to .export_project' do
+      expect(@instance).to respond_to :export_project
+    end
+
+    it 'is expected to export the current project' do
+      expect(@instance).to receive(:post).with(PROJECT_EXPORT_PATH)
+      expect do
+        @instance.export_project
+      end.not_to raise_error
+    end
+  end
+
+  context '.import_project' do
+    it 'should respond to .import_project' do
+      expect(@instance).to respond_to :import_project
+    end
+
+    it 'is expected to import a project' do
+      expect(@instance).to receive(:post).with(
+        PROJECT_IMPORT_PATH, { files: 'files' }
+      )
+      expect do
+        @instance.import_project(files: 'files')
+      end.not_to raise_error
+    end
+  end
+
+  context '.clone_project' do
+    it 'should respond to .clone_project' do
+      expect(@instance).to respond_to :clone_project
+    end
+
+    it 'is expected to clone the current project' do
+      expect(@instance).to receive(:post).with(PROJECT_CLONE, { name: 'test', tag: 'test' })
+      expect { @instance.clone_project(name: 'test', tag: 'test') }.not_to raise_error
+    end
+  end
+end

data/spec/lib.descope/api/v1/management/role_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Descope::Api::V1::Management::Role do
+  before(:all) do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Descope::Api::V1::Management::Role)
+    @instance = dummy_instance
+  end
+
+  context '.create_role' do
+    it 'should respond to .create_role' do
+      expect(@instance).to respond_to :create_role
+    end
+
+    it 'is expected to create a new role' do
+      expect(@instance).to receive(:post).with(
+        ROLE_CREATE_PATH, {
+          name: 'test',
+          description: 'test',
+          permissionNames: ['test']
+        }
+      )
+      expect do
+        @instance.create_role(
+          name: 'test',
+          description: 'test',
+          permission_names: ['test']
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.update_role' do
+    it 'should respond to .update_role' do
+      expect(@instance).to respond_to :update_role
+    end
+
+    it 'is expected to update a role' do
+      expect(@instance).to receive(:post).with(
+        ROLE_UPDATE_PATH, {
+          name: 'test',
+          newName: 'production',
+          description: 'test',
+          permissionNames: ['test']
+        }
+      )
+      expect do
+        @instance.update_role(
+          name: 'test',
+          new_name: 'production',
+          description: 'test',
+          permission_names: ['test']
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.delete_role' do
+    it 'should respond to .delete_role' do
+      expect(@instance).to respond_to :delete_role
+    end
+
+    it 'is expected to delete a role' do
+      expect(@instance).to receive(:post).with(
+        ROLE_DELETE_PATH, { name: 'test' }
+      )
+      expect do
+        @instance.delete_role('test')
+      end.not_to raise_error
+    end
+  end
+
+  context '.load_all_roles' do
+    it 'should respond to .load_all_roles' do
+      expect(@instance).to respond_to :load_all_roles
+    end
+
+    it 'is expected to delete a role' do
+      expect(@instance).to receive(:get).with(ROLE_LOAD_ALL_PATH)
+      expect { @instance.load_all_roles }.not_to raise_error
+    end
+  end
+end