vagrant-cosmic 0.1.0

data/spec/vagrant-cosmic/action/terminate_instance_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+require 'vagrant-cosmic/action/terminate_instance'
+require 'vagrant-cosmic/config'
+
+require 'vagrant'
+require 'fog/cosmic'
+
+describe VagrantPlugins::Cosmic::Action::TerminateInstance do
+  let(:action) { VagrantPlugins::Cosmic::Action::TerminateInstance.new(app, env) }
+
+  let(:destroy_server_response) { { id: JOB_ID } }
+
+  let(:cs_job) { double('Fog::Cosmic::Compute::Job') }
+
+  let(:fake_job_result) do
+    {
+      'queryasyncjobresultresponse' => {
+        'jobstatus' => 1,
+        'jobresult' => {
+          'portforwardingrule' => {
+            'id' => PORT_FORWARDING_RULE_ID
+          },
+          'networkacl' => {
+            'id' => ACL_ID
+          },
+          'virtualmachine' => {
+            'password' => GENERATED_PASSWORD
+          }
+        }
+      }
+    }
+  end
+
+  describe '#terminate_instance in advanced zone' do
+    subject { action.call(env) }
+    let(:app) { double('Vagrant::Action::Warden') }
+
+    let(:provider_config) do
+      config = VagrantPlugins::Cosmic::Config.new
+
+      config.finalize!
+      config.get_domain_config(:cosmic)
+    end
+
+    let(:machine) { double('Vagrant::Machine') }
+    let(:data_dir) { double('Pathname') }
+    let(:a_path) { double('Pathname') }
+    let(:file) { double('File') }
+
+    let(:cosmic_compute) { double('Fog::Cosmic::Compute') }
+    let(:servers) { double('Fog::Cosmic::Compute::Servers') }
+    let(:server) { double('Fog::Cosmic::Compute::Server') }
+    let(:ui) { double('Vagrant::UI::Prefixed') }
+    let(:root_path) { double('Pathname') }
+    let(:env) do
+      {
+        root_path: root_path,
+        ui: ui,
+        machine: machine,
+        cosmic_compute: cosmic_compute
+      }
+    end
+
+    before(:each) do
+      allow(app).to receive(:call).and_return(true)
+
+      allow(ui).to receive(:info)
+      expect(ui).not_to receive(:warn)
+      allow(ui).to receive(:detail)
+
+      allow(machine).to receive(:provider_config).and_return(provider_config)
+      allow(machine).to receive(:data_dir).and_return(data_dir)
+
+      allow(data_dir).to receive(:join).and_return(a_path)
+      allow(a_path).to receive(:file?).and_return(false)
+
+      expect(cosmic_compute).to receive(:servers).and_return(servers)
+      expect(servers).to receive(:get).with(SERVER_ID).and_return(server)
+      expect(server).to receive(:destroy).with('expunge' => false).and_return(cs_job)
+      expect(cs_job).to receive(:id).and_return(JOB_ID)
+
+      allow(cosmic_compute).to receive(:query_async_job_result).with(jobid: JOB_ID).and_return(fake_job_result)
+      allow(machine).to receive(:id).and_return(SERVER_ID)
+      expect(machine).to receive(:id=).with(nil)
+    end
+
+    context 'destroys a simple VM' do
+      it 'destroys a vm' do
+        should eq true
+      end
+
+      context 'with firewall rules removal' do
+        let(:firewall_path) { double('Pathname') }
+        let(:file_content) { double }
+        let(:firewall_rule) { 'UUID of Firewall rule' }
+        let(:network_acl) { 'UUID of ACL' }
+
+        before(:each) do
+          expect(data_dir).to receive(:join).with('firewall').and_return(firewall_path)
+          expect(firewall_path).to receive(:file?).and_return(true)
+          # A VM will never belong to both a VPC and regular router, but allowed for this test
+          allow(File).to receive(:read).and_return("#{network_acl},networkacl\n" + "#{firewall_rule},firewallrule\n")
+
+          expect(cosmic_compute).to receive(:request)
+            .with(command: 'deleteNetworkACL', id: network_acl)
+            .and_return('deletenetworkaclresponse' => { 'jobid' => JOB_ID })
+
+          expect(cosmic_compute).to receive(:request)
+            .with(command: 'deleteFirewallRule', id: 'UUID of Firewall rule')
+            .and_return('deletefirewallruleresponse' => { 'jobid' => JOB_ID })
+
+          expect(firewall_path).to receive(:delete).and_return(true)
+        end
+
+        it 'destroys a vm' do
+          should eq true
+        end
+      end
+
+      context 'with port forwarding removal' do
+        let(:port_forwarding_path) { double('Pathname') }
+
+        before(:each) do
+          expect(data_dir).to receive(:join).with('port_forwarding').and_return(port_forwarding_path)
+          expect(port_forwarding_path).to receive(:file?).and_return(true)
+          allow(File).to receive(:read)
+            .and_return("#{PORT_FORWARDING_RULE_ID}\n#{PORT_FORWARDING_RULE_ID}_2\n#{PORT_FORWARDING_RULE_ID}_3")
+
+          [PORT_FORWARDING_RULE_ID, "#{PORT_FORWARDING_RULE_ID}_2", "#{PORT_FORWARDING_RULE_ID}_3"]
+            .each do |port_forwarding_rule_id|
+
+            expect(cosmic_compute).to receive(:delete_port_forwarding_rule)
+              .with(id: port_forwarding_rule_id)
+              .and_return('deleteportforwardingruleresponse' => { 'jobid' => JOB_ID })
+          end
+          expect(port_forwarding_path).to receive(:delete).and_return(true)
+        end
+
+        it 'destroys a vm' do
+          should eq true
+        end
+      end
+
+      context 'with volume removal' do
+        let(:volumes_path) { double('Pathname') }
+
+        before(:each) do
+          expect(data_dir).to receive(:join).with('volumes').and_return(volumes_path)
+          expect(volumes_path).to receive(:file?).and_return(true)
+          allow(File).to receive(:read)
+            .and_return("#{VOLUME_ID}\n#{VOLUME_ID}_2\n#{VOLUME_ID}_3")
+
+          [VOLUME_ID, "#{VOLUME_ID}_2", "#{VOLUME_ID}_3"]
+            .each do |volume_id|
+
+            expect(cosmic_compute).to receive(:detach_volume)
+              .with(id: volume_id)
+              .and_return('detachvolumeresponse' => { 'jobid' => JOB_ID })
+            expect(cosmic_compute).to receive(:delete_volume)
+              .with(id: volume_id)
+              .and_return('deletevolumeresponse' => { 'success' => 'true' })
+          end
+          expect(volumes_path).to receive(:delete).and_return(true)
+        end
+
+        it 'destroys a vm' do
+          should eq true
+        end
+      end
+
+      context 'with credentials file removal' do
+        let(:credentials_path) { double('Pathname') }
+
+        before(:each) do
+          expect(data_dir).to receive(:join).with('vmcredentials').and_return(credentials_path)
+          expect(credentials_path).to receive(:file?).and_return(true)
+          expect(credentials_path).to receive(:delete).and_return(true)
+        end
+
+        it 'destroys a vm' do
+          should eq true
+        end
+      end
+
+      context 'with generated SSH key removal' do
+        let(:ssh_key_path) { double('Pathname') }
+
+        before(:each) do
+          expect(data_dir).to receive(:join).with('sshkeyname').and_return(ssh_key_path)
+          expect(ssh_key_path).to receive(:file?).and_return(true)
+          allow(File).to receive(:read)
+            .and_return("#{SSH_GENERATED_KEY_NAME}\n")
+
+          expect(cosmic_compute).to receive(:delete_ssh_key_pair)
+            .with(name: SSH_GENERATED_KEY_NAME)
+            .and_return('deletesshkeypairresponse' => { 'success' => 'true' })
+
+          expect(ssh_key_path).to receive(:delete).and_return(true)
+        end
+
+        it 'destroys a vm' do
+          should eq true
+        end
+      end
+    end
+  end
+end

data/spec/vagrant-cosmic/config_spec.rb

@@ -0,0 +1,340 @@
+require "spec_helper"
+require "vagrant-cosmic/config"
+
+describe VagrantPlugins::Cosmic::Config do
+  let(:instance) { described_class.new }
+
+  # Ensure tests are not affected by Cosmic credential environment variables
+  before :each do
+    allow(ENV).to receive_messages(:[] => nil)
+  end
+
+  describe "defaults" do
+    subject do
+      instance.tap do |o|
+        o.finalize!
+      end
+    end
+
+    its("host")                   { should be_nil  }
+    its("path")                   { should be_nil  }
+    its("port")                   { should be_nil  }
+    its("scheme")                 { should be_nil  }
+    its("api_key")                { should be_nil  }
+    its("secret_key")             { should be_nil  }
+    its("instance_ready_timeout") { should == 120  }
+    its("domain_id")              { should be_nil  }
+    its("network_id")             { should be_nil  }
+    its("project_id")             { should be_nil  }
+    its("service_offering_id")    { should be_nil  }
+    its("disk_offering_id")       { should be_nil  }
+    its("template_id")            { should be_nil  }
+    its("zone_id")                { should be_nil  }
+    its("keypair")                { should be_nil  }
+    its("static_nat")             { should == []   }
+    its("pf_ip_address_id")       { should be_nil  }
+    its("pf_ip_address")          { should be_nil  }
+    its("pf_public_port")         { should be_nil  }
+    its("pf_public_rdp_port")     { should be_nil  }
+    its("pf_private_rdp_port")    { should == 3389 }
+    its("pf_public_port_randomrange") { should == {:start=>49152, :end=>65535} }
+    its("pf_private_port")        { should be_nil  }
+    its("pf_open_firewall")       { should == true }
+    its("pf_trusted_networks")    { should be_nil  }
+    its("port_forwarding_rules")  { should == []   }
+    its("firewall_rules")         { should == []   }
+    its("display_name")           { should be_nil  }
+    its("group")                  { should be_nil  }
+    its("user_data")              { should be_nil  }
+    its("ssh_key")                { should be_nil  }
+    its("ssh_user")               { should be_nil  }
+    its("vm_user")                { should be_nil  }
+    its("vm_password")            { should be_nil  }
+    its("private_ip_address")     { should be_nil  }
+    its("expunge_on_destroy")     { should == false  }
+  end
+
+  describe "getting credentials from environment" do
+    context "without Cosmic credential environment variables" do
+      subject do
+        instance.tap do |o|
+          o.finalize!
+        end
+      end
+
+      its("api_key")    { should be_nil }
+      its("secret_key") { should be_nil }
+    end
+
+    context "with Cosmic credential variables" do
+      before :each do
+        allow(ENV).to receive(:[]).with("COSMIC_API_KEY").and_return("api_key")
+        allow(ENV).to receive(:[]).with("COSMIC_SECRET_KEY").and_return("secret_key")
+      end
+
+      subject do
+        instance.tap do |o|
+          o.finalize!
+        end
+      end
+
+      its("api_key")    { should == "api_key" }
+      its("secret_key") { should == "secret_key" }
+    end
+  end
+
+  describe "overriding defaults" do
+    # I typically don't meta-program in tests, but this is a very
+    # simple boilerplate test, so I cut corners here. It just sets
+    # each of these attributes to "foo" in isolation, and reads the value
+    # and asserts the proper result comes back out.
+    [:api_key, :template_id, :zone_id, :instance_ready_timeout,
+      :service_offering_id, :disk_offering_id, :api_key,
+      :secret_key, :network_id, :user_data].each do |attribute|
+
+      it "should not default #{attribute} if overridden" do
+        instance.send("#{attribute}=".to_sym, "foo")
+        instance.finalize!
+        expect(instance.send(attribute)).to be =='foo'
+      end
+
+    end
+
+    it 'should not default pf_open_firewall if overridden' do
+      instance.pf_open_firewall = false
+      instance.finalize!
+
+      expect(instance.pf_open_firewall).to be false
+    end
+  end
+
+  describe "getting credentials from environment" do
+    context "without Cosmic credential environment variables" do
+      subject do
+        instance.tap do |o|
+          o.finalize!
+        end
+      end
+
+      its("api_key")    { should be_nil }
+      its("secret_key") { should be_nil }
+    end
+
+  end
+
+  describe "domain config" do
+    let(:config_host)                   { "foo" }
+    let(:config_path)                   { "foo" }
+    let(:config_port)                   { "foo" }
+    let(:config_scheme)                 { "foo" }
+    let(:config_api_key)                { "foo" }
+    let(:config_secret_key)             { "foo" }
+    let(:config_instance_ready_timeout) { 11111 }
+    let(:config_domain_id)              { "foo" }
+    let(:config_network_id)             { "foo" }
+    let(:config_project_id)             { "foo" }
+    let(:config_service_offering_id)    { "foo" }
+    let(:config_disk_offering_id)       { "foo" }
+    let(:config_template_id)            { "foo" }
+    let(:config_zone_id)                { "foo" }
+    let(:config_keypair)                { "foo" }
+    let(:config_static_nat)             { [{:foo => "bar"}, {:bar => "foo"}] }
+    let(:config_pf_ip_address_id)       { "foo" }
+    let(:config_pf_ip_address)          { "foo" }
+    let(:config_pf_public_port_randomrange)    { {:start=>1, :end=>9} }
+    let(:config_pf_public_port)         { "foo" }
+    let(:config_pf_public_rdp_port)     { "foo" }
+    let(:config_pf_private_rdp_port)    { "foo" }
+    let(:config_pf_private_port)        { "foo" }
+    let(:config_pf_open_firewall)       { false }
+    let(:config_pf_trusted_networks)    { ["foo", "bar"] }
+    let(:config_port_forwarding_rules)  { [{:foo => "bar"}, {:bar => "foo"}] }
+    let(:config_firewall_rules)         { [{:foo => "bar"}, {:bar => "foo"}] }
+    let(:config_display_name)           { "foo" }
+    let(:config_group)                  { "foo" }
+    let(:config_ssh_key)                { "./foo.pem" }
+    let(:config_ssh_user)               { "foo" }
+    let(:config_vm_user)                { "foo" }
+    let(:config_vm_password)            { "foo" }
+    let(:config_private_ip_address)     { "foo" }
+    let(:config_expunge_on_destroy)     { "foo" }
+
+    def set_test_values(instance)
+      instance.host                   = config_host
+      instance.path                   = config_path
+      instance.port                   = config_port
+      instance.scheme                 = config_scheme
+      instance.api_key                = config_api_key
+      instance.secret_key             = config_secret_key
+      instance.instance_ready_timeout = config_instance_ready_timeout
+      instance.domain_id              = config_domain_id
+      instance.network_id             = config_network_id
+      instance.project_id             = config_project_id
+      instance.service_offering_id    = config_service_offering_id
+      instance.disk_offering_id       = config_disk_offering_id
+      instance.template_id            = config_template_id
+      instance.zone_id                = config_zone_id
+      instance.keypair                = config_keypair
+      instance.static_nat             = config_static_nat
+      instance.pf_ip_address_id       = config_pf_ip_address_id
+      instance.pf_public_port_randomrange = config_pf_public_port_randomrange
+      instance.pf_ip_address          = config_pf_ip_address
+      instance.pf_public_port         = config_pf_public_port
+      instance.pf_public_rdp_port     = config_pf_public_rdp_port
+      instance.pf_private_rdp_port    = config_pf_private_rdp_port
+      instance.pf_private_port        = config_pf_private_port
+      instance.pf_open_firewall       = config_pf_open_firewall
+      instance.pf_trusted_networks    = config_pf_trusted_networks
+      instance.port_forwarding_rules  = config_port_forwarding_rules
+      instance.firewall_rules         = config_firewall_rules
+      instance.display_name           = config_display_name
+      instance.group                  = config_group
+      instance.ssh_key                = config_ssh_key
+      instance.ssh_user               = config_ssh_user
+      instance.vm_user                = config_vm_user
+      instance.vm_password            = config_vm_password
+      instance.private_ip_address     = config_private_ip_address
+      instance.expunge_on_destroy     = config_expunge_on_destroy
+    end
+
+    it "should raise an exception if not finalized" do
+      expect { instance.get_domain_config("default") }.
+        to raise_error(RuntimeError)
+    end
+
+    context "with no specific config set" do
+      subject do
+        # Set the values on the top-level object
+        set_test_values(instance)
+
+        # Finalize so we can get the domain config
+        instance.finalize!
+
+        # Get a lower level domain
+        instance.get_domain_config("default")
+      end
+
+      its("host")                   { should == config_host }
+      its("path")                   { should == config_path }
+      its("port")                   { should == config_port }
+      its("scheme")                 { should == config_scheme }
+      its("api_key")                { should == config_api_key }
+      its("secret_key")             { should == config_secret_key }
+      its("instance_ready_timeout") { should == config_instance_ready_timeout }
+      its("domain_id")              { should == config_domain_id }
+      its("network_id")             { should == config_network_id }
+      its("project_id")             { should == config_project_id }
+      its("service_offering_id")    { should == config_service_offering_id }
+      its("disk_offering_id")       { should == config_disk_offering_id }
+      its("template_id")            { should == config_template_id }
+      its("zone_id")                { should == config_zone_id }
+      its("keypair")                { should == config_keypair }
+      its("static_nat")             { should == config_static_nat }
+      its("pf_ip_address_id")       { should == config_pf_ip_address_id }
+      its("pf_ip_address")          { should == config_pf_ip_address }
+      its("pf_public_port")         { should == config_pf_public_port }
+      its("pf_public_rdp_port")     { should == config_pf_public_rdp_port }
+      its("pf_private_rdp_port")    { should == config_pf_private_rdp_port }
+      its("pf_public_port_randomrange") { should == config_pf_public_port_randomrange}
+      its("pf_private_port")        { should == config_pf_private_port }
+      its("pf_trusted_networks")    { should == config_pf_trusted_networks}
+      its("pf_open_firewall")       { should == config_pf_open_firewall }
+      its("port_forwarding_rules")  { should == config_port_forwarding_rules }
+      its("firewall_rules")         { should == config_firewall_rules }
+      its("display_name")           { should == config_display_name }
+      its("group")                  { should == config_group }
+      its("ssh_key")                { should == config_ssh_key }
+      its("ssh_user")               { should == config_ssh_user }
+      its("vm_user")                { should == config_vm_user }
+      its("vm_password")            { should == config_vm_password }
+      its("private_ip_address")     { should == config_private_ip_address }
+      its("expunge_on_destroy")     { should == config_expunge_on_destroy }
+    end
+
+    context "with a specific config set" do
+      let(:domain_name) { "hashi-domain" }
+
+      subject do
+        # Set the values on a specific domain
+        instance.domain_config domain_name do |config|
+          set_test_values(config)
+        end
+
+        # Finalize so we can get the domain config
+        instance.finalize!
+
+        # Get the domain
+        instance.get_domain_config(domain_name)
+      end
+
+      its("host")                   { should == config_host }
+      its("path")                   { should == config_path }
+      its("port")                   { should == config_port }
+      its("scheme")                 { should == config_scheme }
+      its("api_key")                { should == config_api_key }
+      its("secret_key")             { should == config_secret_key }
+      its("instance_ready_timeout") { should == config_instance_ready_timeout }
+      its("domain_id")              { should == config_domain_id }
+      its("network_id")             { should == config_network_id }
+      its("project_id")             { should == config_project_id }
+      its("service_offering_id")    { should == config_service_offering_id }
+      its("disk_offering_id")       { should == config_disk_offering_id }
+      its("template_id")            { should == config_template_id }
+      its("zone_id")                { should == config_zone_id }
+      its("keypair")                { should == config_keypair }
+      its("static_nat")             { should == config_static_nat }
+      its("pf_ip_address_id")       { should == config_pf_ip_address_id }
+      its("pf_ip_address")          { should == config_pf_ip_address }
+      its("pf_public_port")         { should == config_pf_public_port }
+      its("pf_public_rdp_port")     { should == config_pf_public_rdp_port }
+      its("pf_private_rdp_port")    { should == config_pf_private_rdp_port }
+      its("pf_public_port_randomrange") { should == config_pf_public_port_randomrange}
+      its("pf_private_port")        { should == config_pf_private_port }
+      its("pf_open_firewall")       { should == config_pf_open_firewall }
+      its("pf_trusted_networks")    { should == config_pf_trusted_networks}
+      its("port_forwarding_rules")  { should == config_port_forwarding_rules }
+      its("firewall_rules")         { should == config_firewall_rules }
+      its("display_name")           { should == config_display_name }
+      its("group")                  { should == config_group }
+      its("ssh_key")                { should == config_ssh_key }
+      its("ssh_user")               { should == config_ssh_user }
+      its("vm_user")                { should == config_vm_user }
+      its("vm_password")            { should == config_vm_password }
+      its("private_ip_address")     { should == config_private_ip_address }
+      its("expunge_on_destroy")     { should == config_expunge_on_destroy }
+    end
+
+    describe "inheritance of parent config" do
+      let(:domain_name) { "hashi-domain" }
+
+      subject do
+        # Set the values on a specific domain
+        instance.domain_config domain_name do |config|
+          config.template_id = "child"
+        end
+
+        # Set some top-level values
+        instance.api_key     = "parent"
+        instance.template_id = "parent"
+
+        # Finalize and get the domain
+        instance.finalize!
+        instance.get_domain_config(domain_name)
+      end
+
+      its("api_key")     { should == "parent" }
+      its("template_id") { should == "child" }
+    end
+
+    describe "shortcut configuration" do
+      subject do
+        # Use the shortcut configuration to set some values
+        instance.domain_config "Domain1", :template_id => "child"
+        instance.finalize!
+        instance.get_domain_config("Domain1")
+      end
+
+      its("template_id") { should == "child" }
+    end
+  end
+end

data/spec/vagrant-cosmic/model/cosmic_resource_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require 'vagrant-cosmic/model/cosmic_resource'
+
+include VagrantPlugins::Cosmic::Model
+
+describe CosmicResource do
+  context 'when all attribtues are defined' do
+    let(:resource) { CosmicResource.new('id', 'name', 'kind') }
+
+    describe '#to_s' do
+      it 'prints the resource with all attributes' do
+        expect(resource.to_s).to be_eql 'kind - id:name'
+      end
+    end
+
+    describe '#is_undefined?' do
+      it { expect(resource.is_undefined?).to be_eql false }
+    end
+
+    describe '#is_id_undefined?' do
+      it { expect(resource.is_id_undefined?).to be_eql false }
+    end
+
+    describe '#is_name_undefined?' do
+      it { expect(resource.is_name_undefined?).to be_eql false }
+    end
+  end
+
+  context 'when kind is not defined' do
+    describe '#new' do
+      it 'raises an error when kind is nil' do
+        expect { CosmicResource.new('id', 'name', nil) }.to raise_error('Resource must have a kind')
+      end
+
+      it 'raises an error when kind is empty' do
+        expect { CosmicResource.new('id', 'name', '') }.to raise_error('Resource must have a kind')
+      end
+    end
+  end
+
+  describe '#is_undefined?' do
+    it { expect(CosmicResource.new('', '', 'kind').is_undefined?).to be_eql true }
+    it { expect(CosmicResource.new(nil, '', 'kind').is_undefined?).to be_eql true }
+    it { expect(CosmicResource.new('', nil, 'kind').is_undefined?).to be_eql true }
+    it { expect(CosmicResource.new(nil, nil, 'kind').is_undefined?).to be_eql true }
+    it { expect(CosmicResource.new('id', nil, 'kind').is_undefined?).to be_eql false }
+    it { expect(CosmicResource.new(nil, 'name', 'kind').is_undefined?).to be_eql false }
+    it { expect(CosmicResource.new('id', '', 'kind').is_undefined?).to be_eql false }
+    it { expect(CosmicResource.new('', 'name', 'kind').is_undefined?).to be_eql false }
+  end
+
+  describe '#is_id_undefined?' do
+    it { expect(CosmicResource.new('', 'name', 'kind').is_id_undefined?).to be_eql true }
+    it { expect(CosmicResource.new(nil, 'name', 'kind').is_id_undefined?).to be_eql true }
+    it { expect(CosmicResource.new('', '', 'kind').is_id_undefined?).to be_eql true }
+    it { expect(CosmicResource.new(nil, '', 'kind').is_id_undefined?).to be_eql true }
+    it { expect(CosmicResource.new('', nil, 'kind').is_id_undefined?).to be_eql true }
+    it { expect(CosmicResource.new(nil, nil, 'kind').is_id_undefined?).to be_eql true }
+    it { expect(CosmicResource.new('id', nil, 'kind').is_id_undefined?).to be_eql false }
+    it { expect(CosmicResource.new('id', '', 'kind').is_id_undefined?).to be_eql false }
+  end
+
+  describe '#is_name_undefined?' do
+    it { expect(CosmicResource.new('id', '', 'kind').is_name_undefined?).to be_eql true }
+    it { expect(CosmicResource.new('id', nil, 'kind').is_name_undefined?).to be_eql true }
+    it { expect(CosmicResource.new('', '', 'kind').is_name_undefined?).to be_eql true }
+    it { expect(CosmicResource.new(nil, '', 'kind').is_name_undefined?).to be_eql true }
+    it { expect(CosmicResource.new('', nil, 'kind').is_name_undefined?).to be_eql true }
+    it { expect(CosmicResource.new(nil, nil, 'kind').is_name_undefined?).to be_eql true }
+    it { expect(CosmicResource.new(nil, 'name', 'kind').is_name_undefined?).to be_eql false }
+    it { expect(CosmicResource.new('', 'name', 'kind').is_name_undefined?).to be_eql false }
+  end
+
+  describe '#create_id_list' do
+    subject { CosmicResource.create_id_list(ids, kind) }
+
+    let(:kind) { 'network' }
+    let(:ids)  { %w(id1 id2) }
+
+    its(:count) { should eq 2 }
+    its([0])    { should be_a_resource('id1', nil, kind) }
+    its([1])    { should be_a_resource('id2', nil, kind) }
+  end
+
+  describe '#create_name_list' do
+    subject { CosmicResource.create_name_list(names, kind) }
+
+    let(:kind)  { 'network' }
+    let(:names) { %w(name1 name2) }
+
+    its(:count) { should eq 2 }
+    its([0])    { should be_a_resource(nil, 'name1', kind) }
+    its([1])    { should be_a_resource(nil, 'name2', kind) }
+  end
+end

data/spec/vagrant-cosmic/service/cosmic_resource_service_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'vagrant-cosmic/model/cosmic_resource'
+require 'vagrant-cosmic/service/cosmic_resource_service'
+
+include VagrantPlugins::Cosmic::Model
+include VagrantPlugins::Cosmic::Service
+
+describe CosmicResourceService do
+  let(:cosmic_compute) { double('Fog::Cosmic::Compute') }
+  let(:ui) { double('Vagrant::UI') }
+  let(:service) { CosmicResourceService.new(cosmic_compute, ui) }
+
+  before do
+    response = {
+      'listkindsresponse' => {
+        'kind' => [{ 'id' => 'resource id', 'name' => 'resource name' }]
+      }
+    }
+    allow(cosmic_compute).to receive(:send).with(:list_kinds, { 'id' => 'resource id' }).and_return(response)
+    allow(cosmic_compute).to receive(:send).with(:list_kinds, {}).and_return(response)
+
+    allow(ui).to receive(:detail)
+    allow(ui).to receive(:info)
+  end
+
+  describe '#sync_resource' do
+    it 'retrives the missing name' do
+      resource = CosmicResource.new('resource id', nil, 'kind')
+      service.sync_resource(resource)
+
+      expect(resource.name).to be_eql 'resource name'
+      expect(resource.id).to be_eql 'resource id'
+    end
+
+    it 'retrives the missing id' do
+      resource = CosmicResource.new(nil, 'resource name', 'kind')
+      service.sync_resource(resource)
+
+      expect(resource.id).to be_eql 'resource id'
+      expect(resource.name).to be_eql 'resource name'
+    end
+  end
+end