ruby-keystone-client 0.0.1

data/lib/keystone/v2_0/version.rb

@@ -0,0 +1,5 @@
+module Keystone
+  module V2_0
+    VERSION = "0.0.1"
+  end
+end

data/ruby-keystone-client.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'keystone/v2_0/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby-keystone-client"
+  spec.version       = Keystone::V2_0::VERSION
+  spec.authors       = ["Justin Karimi"]
+  spec.email         = ["jekhokie@gmail.com"]
+  spec.summary       = %q{Ruby OpenStack Keystone Client (API V2.0).}
+  spec.description   = %q{A Ruby-based client library to interact with the Keystone service.}
+  spec.homepage      = ""
+  spec.license       = "Apache 2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "rest-client"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "fakeweb"
+end

data/spec/features/client_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+require "keystone/v2_0/client"
+
+describe "Keystone V2.0 client" do
+  let(:username)    { "admin" }
+  let(:password)    { "admin" }
+  let(:tenant_name) { "admin" }
+  let(:auth_url)    { "http://some.host:35357/v2.0" }
+  let(:client)      { Keystone::V2_0::Client.new(username, password, tenant_name, auth_url) }
+  let(:token_id)    { "FGGRGBLRHGLISH988GE" }
+
+  before :each do
+    FakeWeb.clean_registry
+    FakeWeb.register_uri(:post, "#{auth_url}/tokens", :body => "{\"access\":{\"token\":{\"id\":\"#{token_id}\"}}}")
+  end
+
+  describe "initialize" do
+    it "returns an instance when created with parameters" do
+      expect(client).to be_instance_of(Keystone::V2_0::Client)
+    end
+
+    it "dynamically creates manager methods for each query type" do
+      expect(client).to respond_to(:user_interface)
+      expect(client).to respond_to(:role_interface)
+      expect(client).to respond_to(:tenant_interface)
+      expect(client).to respond_to(:service_interface)
+      expect(client).to respond_to(:endpoint_interface)
+    end
+
+    it "returns an Array of query results when the query type is invoked" do
+      data = "{ \"users\": [
+                       { \"username\": \"admin\",
+                         \"name\":     \"admin\",
+                         \"enabled\":  true,
+                         \"email\":    null,
+                         \"id\":       \"49f544c6b0d0403b97d90fe0ee0b585f\" }
+                     ]
+                   }"
+      FakeWeb.register_uri(:get, "#{auth_url}/users", :status => [ 200 ], :body => data)
+      expect(client.user_interface.list).to be_instance_of(Array)
+    end
+
+    it "retuns an exception when no token can be retrieved for the query type" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:post, "#{auth_url}/tokens", :status => [ 404 ], :body => "")
+      expect {
+        client.user_interface.list
+      }.to raise_error
+    end
+  end
+
+  describe "get_token" do
+    it "returns a token for querying" do
+      expect(client.send(:get_token)).to eq(token_id)
+    end
+
+    it "returns nil when no token can be retrieved" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:post, "#{auth_url}/tokens", :status => [ 404 ], :body => "")
+      expect(client.send(:get_token)).to eq(nil)
+    end
+  end
+end

data/spec/features/manager/base_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+require "keystone/v2_0/manager/base"
+require "rest-client"
+
+describe "Keystone V2.0 base manager" do
+  let(:host)          { "some.host" }
+  let(:url_endpoint)  { "/base/endpoint" }
+  let(:priv_port)     { "35357" }
+  let(:auth_url)      { "http://#{host}:#{priv_port}/v2.0/" }
+  let(:base_client)   { Keystone::V2_0::Manager::Base.new(auth_url, url_endpoint) }
+  let(:endpoint_data) { "{ \"blah\": [
+                              { \"adminurl\":    \"http://#{host}:#{priv_port}/v2.0\",
+                                \"service_id\":  \"876fce0975f841fdbebd8352acda75f4\",
+                                \"region\":      \"regionOne\",
+                                \"publicurl\":   \"http://#{host}:5000/v2.0\",
+                                \"enabled\":     true,
+                                \"id\":          \"a584ab022f0348ab9335fa2468960578\",
+                                \"internalurl\": \"http://#{host}:5000/v2.0\" }
+                           ]
+                         }"
+                      }
+
+  describe "initialize" do
+    it "returns an instance when initialized with a URL" do
+      expect(base_client).to be_instance_of(Keystone::V2_0::Manager::Base)
+    end
+
+    it "sets the auth_url on create" do
+      expect(base_client.auth_url).to eq(auth_url)
+    end
+
+    it "sets the url_endpoint on create" do
+      expect(base_client.url_endpoint).to eq(url_endpoint)
+    end
+  end
+
+  describe "list" do
+    it "returns JSON content when query is successful" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 200 ], :body => endpoint_data)
+      expect(base_client.send(:list)).to eq(JSON.parse(endpoint_data))
+    end
+
+    it "returns nil when the query is unsuccessful" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 404 ], :body => "")
+      expect(base_client.send(:list)).to eq(nil)
+    end
+  end
+end

data/spec/features/manager/endpoint_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+require "keystone/v2_0/manager/endpoint"
+
+describe "Keystone V2.0 endpoint manager" do
+  let(:host)            { "some.host" }
+  let(:priv_port)       { "35357" }
+  let(:auth_url)        { "http://#{host}:#{priv_port}/v2.0/" }
+  let(:endpoint_client) { Keystone::V2_0::Manager::Endpoint.new(auth_url) }
+  let(:url_endpoint)    { endpoint_client.url_endpoint }
+  let(:endpoints_data)  { "{ \"endpoints\": [
+                              { \"adminurl\":    \"http://#{host}:#{priv_port}/v2.0\",
+                                \"service_id\":  \"876fce0975f841fdbebd8352acda75f4\",
+                                \"region\":      \"regionOne\",
+                                \"publicurl\":   \"http://#{host}:5000/v2.0\",
+                                \"enabled\":     true,
+                                \"id\":          \"a584ab022f0348ab9335fa2468960578\",
+                                \"internalurl\": \"http://#{host}:5000/v2.0\" }
+                            ]
+                          }"
+                        }
+
+  describe "initialize" do
+    it "returns an instance when initialized with a URL" do
+      expect(endpoint_client).to be_instance_of(Keystone::V2_0::Manager::Endpoint)
+    end
+
+    it "sets the url_endpoint on create" do
+      expect(endpoint_client.url_endpoint).to be_truthy
+    end
+  end
+
+  describe "list" do
+    it "returns a list of Endpoint instances on successful query" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 200 ], :body => endpoints_data)
+      expect(endpoint_client.list.map(&:class)).to eq([ Keystone::V2_0::Resource::Endpoint ])
+    end
+
+    it "returns nil when query is unsuccessful" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 404 ], :body => "")
+      expect(endpoint_client.list).to eq(nil)
+    end
+  end
+
+  describe "create" do
+    let(:service_id)    { "93092u092305920395" }
+    let(:region)        { "test" }
+    let(:admin_url)     { "/something_else" }
+    let(:internal_url)  { "/something" }
+    let(:public_url)    { "/something" }
+    let(:enabled)       { true }
+    let(:endpoint_data) { "{ \"endpoint\":
+                            { \"adminurl\":    \"#{admin_url}\",
+                              \"service_id\":  \"#{service_id}\",
+                              \"region\":      \"#{region}\",
+                              \"enabled\":     #{enabled},
+                              \"id\":          \"q93h08923hg02h03929350h\",
+                              \"internalurl\": \"#{internal_url}\",
+                              \"publicurl\":   \"#{public_url}\" }
+                          }" }
+
+    describe "when successful" do
+      before do
+        FakeWeb.clean_registry
+        FakeWeb.register_uri(:post, "#{auth_url}#{url_endpoint}", :status => [ 200 ], :body => endpoint_data)
+        @endpoint = endpoint_client.create(service_id:   service_id,
+                                           region:       region,
+                                           admin_url:    admin_url,
+                                           internal_url: internal_url,
+                                           public_url:   public_url,
+                                           enabled:      enabled)
+      end
+
+      it "returns a Service instance" do
+        expect(@endpoint).to be_instance_of(Keystone::V2_0::Resource::Endpoint)
+      end
+
+      it "assigns an ID" do
+        expect(@endpoint.id).to be_truthy
+      end
+
+      it "assigns the service_id" do
+        expect(@endpoint.service_id).to eq(service_id)
+      end
+
+      it "assigns the region" do
+        expect(@endpoint.region).to eq(region)
+      end
+
+      it "assigns the admin_url" do
+        expect(@endpoint.admin_url).to eq(admin_url)
+      end
+
+      it "assigns the internal_url" do
+        expect(@endpoint.internal_url).to eq(internal_url)
+      end
+
+      it "assigns the public_url" do
+        expect(@endpoint.public_url).to eq(public_url)
+      end
+
+      it "assigns enabled" do
+        expect(@endpoint.enabled).to eq(enabled)
+      end
+    end
+
+    it "returns nil when not able to be created" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:post, "#{auth_url}#{url_endpoint}", :status => [ 404 ], :body => "")
+      endpoint = endpoint_client.create(service_id:   service_id,
+                                        region:       region,
+                                        admin_url:    admin_url,
+                                        internal_url: internal_url,
+                                        public_url:   public_url,
+                                        enabled:      enabled)
+      expect(@endpoint).to eq(nil)
+    end
+  end
+end

data/spec/features/manager/role_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "keystone/v2_0/manager/role"
+
+describe "Keystone V2.0 role manager" do
+  let(:host)         { "some.host" }
+  let(:priv_port)    { "35357" }
+  let(:auth_url)     { "http://#{host}:#{priv_port}/v2.0/" }
+  let(:role_client)  { Keystone::V2_0::Manager::Role.new(auth_url) }
+  let(:url_endpoint) { role_client.url_endpoint }
+  let(:roles_data)   { "{ \"roles\": [
+                            { \"enabled\":     \"True\",
+                              \"description\": \"Default role for project membership\",
+                              \"name\":        \"_member_\",
+                              \"id\":          \"9fe2ff9ee4384b1894a90878d3e92bab\" },
+                            { \"id\":          \"e409aeca08b548ceb94ced546e1a4a18\",
+                              \"name\":        \"admin\" }
+                          ]
+                        }"
+                     }
+
+  describe "initialize" do
+    it "returns an instance when initialized with a URL" do
+      expect(role_client).to be_instance_of(Keystone::V2_0::Manager::Role)
+    end
+
+    it "sets the url_endpoint on create" do
+      expect(role_client.url_endpoint).to be_truthy
+    end
+  end
+
+  describe "list" do
+    it "returns a list of Role instances on successful query" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 200 ], :body => roles_data)
+      expect(role_client.list.map(&:class)).to eq([ Keystone::V2_0::Resource::Role, Keystone::V2_0::Resource::Role ])
+    end
+
+    it "returns nil when query is unsuccessful" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 404 ], :body => "")
+      expect(role_client.list).to eq(nil)
+    end
+  end
+end

data/spec/features/manager/service_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+require "keystone/v2_0/manager/service"
+
+describe "Keystone V2.0 service manager" do
+  let(:host)           { "some.host" }
+  let(:priv_port)      { "35357" }
+  let(:auth_url)       { "http://#{host}:#{priv_port}/v2.0/" }
+  let(:service_client) { Keystone::V2_0::Manager::Service.new(auth_url) }
+  let(:url_endpoint)   { service_client.url_endpoint }
+  let(:services_data)  { "{ \"OS-KSADM:services\": [
+                            { \"id\":          \"876fce0975f841fdbebd8352acda75f4\",
+                              \"enabled\":     true,
+                              \"type\":        \"identity\",
+                              \"name\":        \"keystone\",
+                              \"description\": \"Keystone Identity Service\"}
+                           ]
+                         }"
+                       }
+
+  describe "initialize" do
+    it "returns an instance when initialized with a URL" do
+      expect(service_client).to be_instance_of(Keystone::V2_0::Manager::Service)
+    end
+
+    it "sets the url_endpoint on create" do
+      expect(service_client.url_endpoint).to be_truthy
+    end
+  end
+
+  describe "list" do
+    it "returns a list of Service instances on successful query" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 200 ], :body => services_data)
+      expect(service_client.list.map(&:class)).to eq([ Keystone::V2_0::Resource::Service ])
+    end
+
+    it "returns nil when query is unsuccessful" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 404 ], :body => "")
+      expect(service_client.list).to eq(nil)
+    end
+  end
+
+  describe "create" do
+    let(:name)         { "test" }
+    let(:type)         { "test tool" }
+    let(:description)  { "Some kind of test" }
+    let(:service_data) { "{ \"OS-KSADM:service\":
+                            { \"id\":          \"43dc90f2398b4510acc8f07901e30ed8\",
+                              \"enabled\":     true,
+                              \"type\":        \"#{type}\",
+                              \"name\":        \"#{name}\",
+                              \"description\": \"#{description}\" }
+                          }" }
+
+    describe "when successful" do
+      before do
+        FakeWeb.clean_registry
+        FakeWeb.register_uri(:post, "#{auth_url}#{url_endpoint}", :status => [ 200 ], :body => service_data)
+        @service = service_client.create(name: name, type: type, description: description)
+      end
+
+      it "returns a Service instance" do
+        expect(@service).to be_instance_of(Keystone::V2_0::Resource::Service)
+      end
+
+      it "assigns an ID" do
+        expect(@service.id).to be_truthy
+      end
+
+      it "assigns the name" do
+        expect(@service.name).to eq(name)
+      end
+
+      it "assigns the type" do
+        expect(@service.type).to eq(type)
+      end
+
+      it "assigns the description" do
+        expect(@service.description).to eq(description)
+      end
+    end
+
+    it "returns nil when not able to be created" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:post, "#{auth_url}#{url_endpoint}", :status => [ 404 ], :body => "")
+      service = service_client.create(name: name, type: type, description: description)
+      expect(@service).to eq(nil)
+    end
+  end
+end

data/spec/features/manager/tenant_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "keystone/v2_0/manager/tenant"
+
+describe "Keystone V2.0 tenant manager" do
+  let(:host)          { "some.host" }
+  let(:priv_port)     { "35357" }
+  let(:auth_url)      { "http://#{host}:#{priv_port}/v2.0/" }
+  let(:tenant_client) { Keystone::V2_0::Manager::Tenant.new(auth_url) }
+  let(:url_endpoint)  { tenant_client.url_endpoint }
+  let(:tenants_data)  { "{ \"tenants\": [
+                            { \"description\": \"Admin Tenant\",
+                              \"enabled\":     true,
+                              \"id\":          \"9958cfb44628476b8f16996e76703292\",
+                              \"name\":        \"admin\" }
+                           ]
+                         }"
+                       }
+
+  describe "initialize" do
+    it "returns an instance when initialized with a URL" do
+      expect(tenant_client).to be_instance_of(Keystone::V2_0::Manager::Tenant)
+    end
+
+    it "sets the url_endpoint on create" do
+      expect(tenant_client.url_endpoint).to be_truthy
+    end
+  end
+
+  describe "list" do
+    it "returns a list of Tenant instances on successful query" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 200 ], :body => tenants_data)
+      expect(tenant_client.list.map(&:class)).to eq([ Keystone::V2_0::Resource::Tenant ])
+    end
+
+    it "returns nil when query is unsuccessful" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 404 ], :body => "")
+      expect(tenant_client.list).to eq(nil)
+    end
+  end
+end

data/spec/features/manager/user_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+require "keystone/v2_0/manager/user"
+
+describe "Keystone V2.0 user manager" do
+  let(:host)         { "some.host" }
+  let(:priv_port)    { "35357" }
+  let(:auth_url)     { "http://#{host}:#{priv_port}/v2.0/" }
+  let(:user_client)  { Keystone::V2_0::Manager::User.new(auth_url) }
+  let(:url_endpoint) { user_client.url_endpoint }
+  let(:users_data)   { "{ \"users\": [
+                         { \"username\": \"admin\",
+                           \"name\":     \"admin\",
+                           \"enabled\":  true,
+                           \"email\":    null,
+                           \"id\":       \"49f544c6b0d0403b97d90fe0ee0b585f\" }
+                         ]
+                       }"
+                     }
+
+  describe "initialize" do
+    it "returns an instance when initialized with a URL" do
+      expect(user_client).to be_instance_of(Keystone::V2_0::Manager::User)
+    end
+
+    it "sets the url_endpoint on create" do
+      expect(user_client.url_endpoint).to be_truthy
+    end
+  end
+
+  describe "list" do
+    it "returns a list of User instances on successful query" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 200 ], :body => users_data)
+      expect(user_client.list.map(&:class)).to eq([ Keystone::V2_0::Resource::User ])
+    end
+
+    it "returns nil when query is unsuccessful" do
+      FakeWeb.clean_registry
+      FakeWeb.register_uri(:get, "#{auth_url}#{url_endpoint}", :status => [ 404 ], :body => "")
+      expect(user_client.list).to eq(nil)
+    end
+  end
+end

data/spec/features/resource/endpoint_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+require "keystone/v2_0/resource/endpoint"
+
+describe "Keystone V2.0 endpoint resource" do
+  let(:admin_url)     { "http://some.host:35357/v2.0" }
+  let(:internal_url)  { "http://some.host:35357/v2.0" }
+  let(:public_url)    { "http://some.host:5000/v2.0" }
+  let(:id)            { "w09ehg0923ht9" }
+  let(:enabled)       { true }
+  let(:region)        { "Region1" }
+  let(:service_id)    { "930uty09gh209gh" }
+  let(:endpoint_data) { "{ \"adminurl\":    \"#{admin_url}\",
+                           \"service_id\":  \"#{service_id}\",
+                           \"region\":      \"#{region}\",
+                           \"publicurl\":   \"#{public_url}\",
+                           \"enabled\":     #{enabled},
+                           \"id\":          \"#{id}\",
+                           \"internalurl\": \"#{internal_url}\" }"
+                      }
+
+  it "responds with the attribute mappings" do
+    expect(Keystone::V2_0::Resource::Endpoint.attr_mappings).to be_truthy
+  end
+
+  describe "initialize" do
+    let(:resource) { Keystone::V2_0::Resource::Endpoint.new(JSON.parse(endpoint_data)) }
+
+    it "returns an Endpoint resource on initailize" do
+      expect(resource).to be_instance_of(Keystone::V2_0::Resource::Endpoint)
+    end
+
+    it "assigns the admin_url attribute" do
+      expect(resource.admin_url).to eq(admin_url)
+    end
+
+    it "assigns the service_id attribute" do
+      expect(resource.service_id).to eq(service_id)
+    end
+
+    it "assigns the region attribute" do
+      expect(resource.region).to eq(region)
+    end
+
+    it "assigns the public_url attribute" do
+      expect(resource.public_url).to eq(public_url)
+    end
+
+    it "assigns the enabled attribute" do
+      expect(resource.enabled).to eq(enabled)
+    end
+
+    it "assigns the id attribute" do
+      expect(resource.id).to eq(id)
+    end
+
+    it "assigns the internal_url attribute" do
+      expect(resource.internal_url).to eq(internal_url)
+    end
+  end
+end

data/spec/features/resource/role_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "keystone/v2_0/resource/role"
+
+describe "Keystone V2.0 role resource" do
+  let(:name)        { "test" }
+  let(:enabled)     { "True" }
+  let(:description) { "testing this out" }
+  let(:id)          { "930uty09gh209gh" }
+  let(:role_data)   { "{ \"enabled\":     \"#{enabled}\",
+                         \"description\": \"#{description}\",
+                         \"name\":        \"#{name}\",
+                         \"id\":          \"#{id}\" }"
+                    }
+
+  it "responds with the attribute mappings" do
+    expect(Keystone::V2_0::Resource::Role.attr_mappings).to be_truthy
+  end
+
+  describe "initialize" do
+    let(:resource) { Keystone::V2_0::Resource::Role.new(JSON.parse(role_data)) }
+
+    it "returns a Role resource on initailize" do
+      expect(resource).to be_instance_of(Keystone::V2_0::Resource::Role)
+    end
+
+    it "assigns the enabled attribute" do
+      expect(resource.enabled).to eq(enabled)
+    end
+
+    it "assigns the description attribute" do
+      expect(resource.description).to eq(description)
+    end
+
+    it "assigns the name attribute" do
+      expect(resource.name).to eq(name)
+    end
+
+    it "assigns the id attribute" do
+      expect(resource.id).to eq(id)
+    end
+  end
+end

data/spec/features/resource/service_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+require "keystone/v2_0/resource/service"
+
+describe "Keystone V2.0 service resource" do
+  let(:name)         { "keystone" }
+  let(:enabled)      { true }
+  let(:type)         { "identity" }
+  let(:id)           { "930uty09gh209gh" }
+  let(:description)  { "testing this out" }
+  let(:service_data) { "{ \"id\":          \"#{id}\",
+                          \"enabled\":     #{enabled},
+                          \"type\":        \"#{type}\",
+                          \"name\":        \"#{name}\",
+                          \"description\": \"#{description}\"} "
+                     }
+
+  it "responds with the attribute mappings" do
+    expect(Keystone::V2_0::Resource::Endpoint.attr_mappings).to be_truthy
+  end
+
+  describe "initialize" do
+    let(:resource) { Keystone::V2_0::Resource::Service.new(JSON.parse(service_data)) }
+
+    it "returns a Service resource on initailize" do
+      expect(resource).to be_instance_of(Keystone::V2_0::Resource::Service)
+    end
+
+    it "assigns the id attribute" do
+      expect(resource.id).to eq(id)
+    end
+
+    it "assigns the enabled attribute" do
+      expect(resource.enabled).to eq(enabled)
+    end
+
+    it "assigns the type attribute" do
+      expect(resource.type).to eq(type)
+    end
+
+    it "assigns the name attribute" do
+      expect(resource.name).to eq(name)
+    end
+
+    it "assigns the description attribute" do
+      expect(resource.description).to eq(description)
+    end
+  end
+end