knife-ionoscloud 5.0.0.beta.1

data/spec/chef/knife/ionoscloud_group_create_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'ionoscloud_group_create'
+
+Chef::Knife::IonoscloudGroupCreate.load_deps
+
+describe Chef::Knife::IonoscloudGroupCreate do
+  before :each do
+    subject { Chef::Knife::IonoscloudGroupCreate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call UserManagementApi.um_groups_post with the expected arguments and output based on what it receives' do
+      group = group_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        name: group.properties.name,
+        create_data_center: group.properties.create_data_center,
+        create_snapshot: group.properties.create_snapshot,
+        reserve_ip: group.properties.reserve_ip,
+        access_activity_log: group.properties.access_activity_log,
+        s3_privilege: group.properties.s3_privilege,
+        create_backup_unit: group.properties.create_backup_unit,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject).to receive(:puts).with("ID: #{group.id}")
+      expect(subject).to receive(:puts).with("Name: #{group.properties.name}")
+      expect(subject).to receive(:puts).with("Create Datacenter: #{group.properties.create_data_center.to_s}")
+      expect(subject).to receive(:puts).with("Create Snapshot: #{group.properties.create_snapshot.to_s}")
+      expect(subject).to receive(:puts).with("Reserve IP: #{group.properties.reserve_ip.to_s}")
+      expect(subject).to receive(:puts).with("Access Activity Log: #{group.properties.access_activity_log.to_s}")
+      expect(subject).to receive(:puts).with("S3 Privilege: #{group.properties.s3_privilege.to_s}")
+      expect(subject).to receive(:puts).with("Create Backup Unit: #{group.properties.create_backup_unit.to_s}")
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'POST',
+            path: '/um/groups',
+            operation: :'UserManagementApi.um_groups_post',
+            return_type: 'Group',
+            body: { properties: group.properties.to_hash },
+            result: group,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      arrays_without_one_element(required_options).each do |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_group_delete_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'ionoscloud_group_delete'
+
+Chef::Knife::IonoscloudGroupDelete.load_deps
+
+describe Chef::Knife::IonoscloudGroupDelete do
+  before :each do
+    subject { Chef::Knife::IonoscloudGroupDelete.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call UserManagementApi.um_groups_delete when the ID is valid' do
+      group = group_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [group.id]
+
+      users = group.entities.users.items.map { |el| el.id }
+
+      expect(subject).to receive(:puts).with("ID: #{group.id}")
+      expect(subject).to receive(:puts).with("Name: #{group.properties.name}")
+      expect(subject).to receive(:puts).with("Create Datacenter: #{group.properties.create_data_center.to_s}")
+      expect(subject).to receive(:puts).with("Create Snapshot: #{group.properties.create_snapshot.to_s}")
+      expect(subject).to receive(:puts).with("Reserve IP: #{group.properties.reserve_ip.to_s}")
+      expect(subject).to receive(:puts).with("Access Activity Log: #{group.properties.access_activity_log.to_s}")
+      expect(subject).to receive(:puts).with("S3 Privilege: #{group.properties.s3_privilege.to_s}")
+      expect(subject).to receive(:puts).with("Create Backup Unit: #{group.properties.create_backup_unit.to_s}")
+      expect(subject).to receive(:puts).with("Users: #{users.to_s}")
+      expect(subject.ui).to receive(:warn).with("Deleted Group #{group.id}. Request ID: ")
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      expect(subject).to receive(:get_request_id).once
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/um/groups/#{group.id}",
+            operation: :'UserManagementApi.um_groups_find_by_id',
+            return_type: 'Group',
+            result: group,
+          },
+          {
+            method: 'DELETE',
+            path: "/um/groups/#{group.id}",
+            operation: :'UserManagementApi.um_groups_delete',
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not call UserManagementApi.um_groups_delete when the ID is not valid' do
+      group_id = 'invalid_id'
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [group_id]
+
+      expect(subject.ui).to receive(:error).with("Group ID #{group_id} not found. Skipping.")
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/um/groups/#{group_id}",
+            operation: :'UserManagementApi.um_groups_find_by_id',
+            return_type: 'Group',
+            exception: Ionoscloud::ApiError.new(code: 404),
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      arrays_without_one_element(required_options).each do |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_group_get_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'ionoscloud_group_get'
+
+Chef::Knife::IonoscloudGroupGet.load_deps
+
+describe Chef::Knife::IonoscloudGroupGet do
+  before :each do
+    subject { Chef::Knife::IonoscloudGroupGet.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call UserManagementApi.um_groups_find_by_id' do
+      group = group_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+        group_id: group.id,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+
+      users = group.entities.users.items.map { |el| el.id }
+
+      expect(subject).to receive(:puts).with("ID: #{group.id}")
+      expect(subject).to receive(:puts).with("Name: #{group.properties.name}")
+      expect(subject).to receive(:puts).with("Create Datacenter: #{group.properties.create_data_center.to_s}")
+      expect(subject).to receive(:puts).with("Create Snapshot: #{group.properties.create_snapshot.to_s}")
+      expect(subject).to receive(:puts).with("Reserve IP: #{group.properties.reserve_ip.to_s}")
+      expect(subject).to receive(:puts).with("Access Activity Log: #{group.properties.access_activity_log.to_s}")
+      expect(subject).to receive(:puts).with("S3 Privilege: #{group.properties.s3_privilege.to_s}")
+      expect(subject).to receive(:puts).with("Create Backup Unit: #{group.properties.create_backup_unit.to_s}")
+      expect(subject).to receive(:puts).with("Users: #{users.to_s}")
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/um/groups/#{subject_config[:group_id]}",
+            operation: :'UserManagementApi.um_groups_find_by_id',
+            return_type: 'Group',
+            result: group,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      arrays_without_one_element(required_options).each do |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_group_list_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require 'ionoscloud_group_list'
+
+Chef::Knife::IonoscloudGroupList.load_deps
+
+describe Chef::Knife::IonoscloudGroupList do
+  before :each do
+    subject { Chef::Knife::IonoscloudGroupList.new }
+
+    @groups = groups_mock
+    @group_list = group_list = [
+      subject.ui.color('ID', :bold),
+      subject.ui.color('Name', :bold),
+      subject.ui.color('Create Datacenter', :bold),
+      subject.ui.color('Create Snapshot', :bold),
+      subject.ui.color('Reserve IP', :bold),
+      subject.ui.color('Access Activity Log', :bold),
+      subject.ui.color('S3 Privilege', :bold),
+      subject.ui.color('Create Backup Unit', :bold),
+      @groups.items.first.id,
+      @groups.items.first.properties.name,
+      @groups.items.first.properties.create_data_center.to_s,
+      @groups.items.first.properties.create_snapshot.to_s,
+      @groups.items.first.properties.reserve_ip.to_s,
+      @groups.items.first.properties.access_activity_log.to_s,
+      @groups.items.first.properties.s3_privilege.to_s,
+      @groups.items.first.properties.create_backup_unit.to_s,
+      @groups.items[1].id,
+      @groups.items[1].properties.name,
+      @groups.items[1].properties.create_data_center.to_s,
+      @groups.items[1].properties.create_snapshot.to_s,
+      @groups.items[1].properties.reserve_ip.to_s,
+      @groups.items[1].properties.access_activity_log.to_s,
+      @groups.items[1].properties.s3_privilege.to_s,
+      @groups.items[1].properties.create_backup_unit.to_s,
+    ]
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call UserManagementApi.um_groups_get when no user_id is set' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@group_list, :uneven_columns_across, 8)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/um/groups',
+            operation: :'UserManagementApi.um_groups_get',
+            return_type: 'Groups',
+            result: @groups,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call UserManagementApi.um_groups_groups_get when user_id is set' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        user_id: 'user_id'
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@group_list, :uneven_columns_across, 8)
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/um/users/#{subject_config[:user_id]}/groups",
+            operation: :'UserManagementApi.um_users_groups_get',
+            return_type: 'ResourceGroups',
+            result: @groups,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      arrays_without_one_element(required_options).each do |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_group_user_add_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'ionoscloud_group_user_add'
+
+Chef::Knife::IonoscloudGroupUserAdd.load_deps
+
+describe Chef::Knife::IonoscloudGroupUserAdd do
+  before :each do
+    subject { Chef::Knife::IonoscloudGroupUserAdd.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call UserManagementApi.um_groups_users_post when the ID is valid' do
+      group = group_mock
+      user = user_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        group_id: group.id,
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [user.id]
+
+      users = group.entities.users.items.map { |user| user.id }
+
+      expect(subject).to receive(:puts).with("ID: #{group.id}")
+      expect(subject).to receive(:puts).with("Name: #{group.properties.name}")
+      expect(subject).to receive(:puts).with("Create Datacenter: #{group.properties.create_data_center.to_s}")
+      expect(subject).to receive(:puts).with("Create Snapshot: #{group.properties.create_snapshot.to_s}")
+      expect(subject).to receive(:puts).with("Reserve IP: #{group.properties.reserve_ip.to_s}")
+      expect(subject).to receive(:puts).with("Access Activity Log: #{group.properties.access_activity_log.to_s}")
+      expect(subject).to receive(:puts).with("S3 Privilege: #{group.properties.s3_privilege.to_s}")
+      expect(subject).to receive(:puts).with("Create Backup Unit: #{group.properties.create_backup_unit.to_s}")
+      expect(subject).to receive(:puts).with("Users: #{users.to_s}")
+      expect(subject.ui).to receive(:info).with("Added User #{user.id} to the Group #{group.id}. Request ID: .")
+
+      expect(subject).to receive(:get_request_id).once
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'POST',
+            path: "/um/groups/#{group.id}/users",
+            operation: :'UserManagementApi.um_groups_users_post',
+            body: { id: user.id },
+            return_type: 'User',
+          },
+          {
+            method: 'GET',
+            path: "/um/groups/#{group.id}",
+            operation: :'UserManagementApi.um_groups_find_by_id',
+            return_type: 'Group',
+            result: group,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not call UserManagementApi.um_groups_users_post when the ID is not valid' do
+      group = group_mock
+      user_id = 'invalid_id'
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        group_id: group.id,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [user_id]
+
+      users = group.entities.users.items.map { |user| user.id }
+
+      expect(subject).to receive(:puts).with("ID: #{group.id}")
+      expect(subject).to receive(:puts).with("Name: #{group.properties.name}")
+      expect(subject).to receive(:puts).with("Create Datacenter: #{group.properties.create_data_center.to_s}")
+      expect(subject).to receive(:puts).with("Create Snapshot: #{group.properties.create_snapshot.to_s}")
+      expect(subject).to receive(:puts).with("Reserve IP: #{group.properties.reserve_ip.to_s}")
+      expect(subject).to receive(:puts).with("Access Activity Log: #{group.properties.access_activity_log.to_s}")
+      expect(subject).to receive(:puts).with("S3 Privilege: #{group.properties.s3_privilege.to_s}")
+      expect(subject).to receive(:puts).with("Create Backup Unit: #{group.properties.create_backup_unit.to_s}")
+      expect(subject).to receive(:puts).with("Users: #{users.to_s}")
+      expect(subject.ui).to receive(:error).with("User ID #{user_id} not found. Skipping.")
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'POST',
+            path: "/um/groups/#{subject_config[:group_id]}/users",
+            operation: :'UserManagementApi.um_groups_users_post',
+            body: { id: user_id },
+            return_type: 'User',
+            exception: Ionoscloud::ApiError.new(code: 404),
+          },
+          {
+            method: 'GET',
+            path: "/um/groups/#{group.id}",
+            operation: :'UserManagementApi.um_groups_find_by_id',
+            return_type: 'Group',
+            result: group,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      arrays_without_one_element(required_options).each do |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      end
+    end
+  end
+end