conjur-cli 5.6.6 → 6.0.0.rc1

data/spec/command/variables_spec.rb

@@ -1,192 +0,0 @@
-require 'spec_helper'
-
-describe Conjur::Command::Variables, logged_in: true do
-  let(:host) { 'https://core.example.com/api' }
-  let(:collection_url) { "#{host}/variables" }
-  let(:mime_type) { 'text/plain' }
-  let(:kind) { 'secret' }
-  let(:base_payload) do
-    { id: id, value: value, mime_type: mime_type, kind: kind }.tap do |t|
-      group && t.merge(ownerid: group)
-    end
-  end
-  let(:id) { 'the-id' }
-  let(:variable) { post_response(id) }
-  let(:group) { nil }
-  let(:annotation) { {} }
-  let(:value) { 'the-value' }
-  let(:full_payload) { base_payload }
-  
-  context 'when there are command-line errors' do
-    describe_command "variable:create -v the-value-1 the-id the-value-2" do
-      it "complains about conflicting values" do
-        expect { invoke }.to raise_error("Received conflicting value arguments")
-      end
-    end
-  end
-
-  context "-a without -i" do
-    describe_command 'variable:create -a the-id' do
-      it "is an error" do
-        expect { invoke }.to raise_error("Received --annotate option without --interactive")
-      end
-    end
-  end
-  
-  context 'non-interactive' do
-    describe_command "variable:create the-id" do
-      it "is non-interactive" do
-        allow(Conjur::Command::Variables).to receive(:prompt_for_id).and_raise("Unexpected prompt for id")
-        expect(RestClient::Request).to receive(:execute).and_return(variable)
-        invoke
-      end
-    end
-  end
-
-  context 'when there are no command-line errors' do
-    before do
-      allow(Conjur::Command::Variables).to receive(:prompt_to_confirm) { "yes"}
-      allow(Conjur::Command::Variables).to receive(:prompt_for_id) { id }
-      allow(Conjur::Command::Variables).to receive(:prompt_for_group) { group }
-      allow(Conjur::Command::Variables).to receive(:prompt_for_kind) { kind }
-      allow(Conjur::Command::Variables).to receive(:prompt_for_mime_type) { mime_type }
-      allow(Conjur::Command::Variables).to receive(:prompt_for_annotations) { annotation }
-      allow(Conjur::Command::Variables).to receive(:prompt_for_value)  { value }
-        
-      expect(RestClient::Request).to receive(:execute).with({
-          method: :post,
-          url: collection_url,
-          headers: {},
-          payload: full_payload
-        }).and_return(variable)
-    end
-    
-    describe_command "variable:create the-id the-different-value" do
-      let (:value) { 'the-different-value' }
-      it "propagates the user-assigned id" do
-        expect { invoke }.to write({ id: 'the-id' }).to(:stdout)
-      end
-    end
-    
-    describe_command "variable:create the-id" do
-      let(:value) { "" }
-      let(:full_payload) { 
-        base_payload.dup.tap do |m|
-          m.delete_if{|k,_| k == :value}
-        end
-      }
-      it "will propagate the user-assigned id without a value" do
-        expect { invoke }.to write({ id: 'the-id' }).to(:stdout)
-      end
-    end
-    
-    let(:base_payload) do
-      { id: id, value: value, mime_type: mime_type, kind: kind }.tap do |t|
-        group && t.merge(ownerid: group)
-      end
-    end
-
-    describe_command "variable:create -m application/json" do
-      let(:mime_type) { 'application/json' }
-      let(:payload) { valueless_payload }
-      it "propagates the user-assigned MIME type" do
-        expect { invoke }.to write({ id: 'the-id' }).to(:stdout)
-      end
-    end
-    
-    describe_command "variable:create -k password" do
-      let(:kind) { 'password' }
-      let(:payload) { valueless_payload }
-      it "propagates the user-assigned kind" do
-        expect { invoke }.to write({ id: 'the-id' }).to(:stdout)
-      end
-    end
-    
-    describe "in interactive mode" do
-      after do
-        expect { invoke }.to write({ id: 'the-id' }).to(:stdout)
-      end
-      
-      subject { Conjur::Command::Variables }
-      
-      context "when -i is omitted" do
-        describe_command 'variable:create' do
-          it { is_expected.to receive(:prompt_for_id) }
-          it { is_expected.to receive(:prompt_for_group) }
-          it { is_expected.to receive(:prompt_for_kind) }
-          it { is_expected.to receive(:prompt_for_mime_type) }
-          it { is_expected.not_to receive(:prompt_for_annotations) }
-          it { is_expected.to receive(:prompt_for_value) }
-        end
-        
-        describe_command 'variable:create the-id the-value' do
-          it { is_expected.not_to receive(:prompt_for_id) }
-          it { is_expected.not_to receive(:prompt_for_value) }
-        end
-        
-        describe_command 'variable:create -m application/json' do
-          let(:mime_type) { 'application/json' }
-          it { is_expected.not_to receive(:prompt_for_mime_type) }
-        end
-        
-        describe_command 'variable:create -k password' do
-          let(:kind) { 'password' }
-          it { is_expected.not_to receive(:prompt_for_kind) }
-        end
-        
-        describe_command 'variable:create -v the-value' do
-          it { is_expected.not_to receive(:prompt_for_value) }
-        end
-
-        describe_command 'variable:create --as-group the-group' do
-          before do
-            allow(RestClient::Request).to receive(:execute).with({
-                method: :head,
-                url: 'https://authz.example.com/the-account/roles/group/the-group',
-                headers: {}
-              }).and_return(OpenStruct.new(headers: {}, body: '{}'))
-          end
-            
-          let(:full_payload) { base_payload.merge(ownerid: 'the-account:group:the-group') }
-
-          it { is_expected.not_to receive(:prompt_for_group) }
-        end
-
-        describe_command 'variable:create --as-role the-account:group:the-group' do
-          before do
-            allow(RestClient::Request).to receive(:execute).with({
-                method: :head,
-                url: 'https://authz.example.com/the-account/roles/group/the-group',
-                headers: {}
-              }).and_return(OpenStruct.new(headers: {}, body: '{}'))
-          end
-            
-          let(:full_payload) { base_payload.merge(ownerid: 'the-account:group:the-group') }
-
-          it { is_expected.not_to receive(:prompt_for_group) }
-        end
-        
-      end
-      
-      context "explicit interactivity" do
-        describe_command 'variable:create -i the-id the-value' do
-          it { is_expected.not_to receive(:prompt_for_id) }
-          it { is_expected.not_to receive(:prompt_for_value) }
-          it { is_expected.to receive(:prompt_for_group) }
-          it { is_expected.to receive(:prompt_for_mime_type) }
-          it { is_expected.to receive(:prompt_for_kind) }
-          it { is_expected.not_to receive(:prompt_for_annotations) }
-        end
-      end
-      
-      context "interactive annotations" do
-        describe_command 'variable:create -a' do
-          it { is_expected.to receive(:prompt_for_annotations) }
-        end
-        describe_command 'variable:create -ia the-id' do
-          it { is_expected.to receive(:prompt_for_annotations) }
-        end
-      end
-    end
-  end
-end

data/spec/conjurize/script_spec.rb

@@ -1,62 +0,0 @@
-require "spec_helper"
-require "conjur/conjurize/script"
-
-describe Conjur::Conjurize::Script do
-  describe ".latest_conjur_cookbook_release" do
-    let(:releases_json) do
-      %([
-        {
-          "name": "v0.4.0",
-          "assets": [{
-            "name": "conjur-v0.4.0.tar.gz",
-            "browser_download_url": "http://example.com/conjur-v0.4.0.tar.gz"
-          }]
-        },
-        {
-          "name": "v0.3.0",
-          "assets": [{
-            "name": "conjur-v0.3.0.tar.gz",
-            "browser_download_url": "http://example.com/conjur-v0.3.0.tar.gz"
-          }]
-        }
-      ])
-    end
-
-    before do
-      allow(Conjur::Conjurize::Script).to receive(:open)\
-        .with("https://api.github.com/repos/conjur-cookbooks/conjur/releases")\
-        .and_return double(read: releases_json)
-    end
-
-    it "looks up the latest release download url" do
-      expect(Conjur::Conjurize::Script.latest_conjur_cookbook_release).to \
-        eq "http://example.com/conjur-v0.4.0.tar.gz"
-    end
-
-    context "with latest release is without any tarballs" do
-      let(:releases_json) do
-        %([
-          {
-            "name": "v0.4.0",
-            "assets": []
-          },
-          {
-            "name": "v0.3.0",
-            "assets": [{
-              "name": "conjur-v0.3.0.tar.gz",
-              "browser_download_url": "http://example.com/conjur-v0.3.0.tar.gz"
-            }]
-          }
-        ])
-      end
-
-      it "returns the previous one and warns" do
-        err = $stderr.grab do
-          expect(Conjur::Conjurize::Script.latest_conjur_cookbook_release).to \
-            eq "http://example.com/conjur-v0.3.0.tar.gz"
-        end
-        expect(err).to include "WARNING"
-      end
-    end
-  end
-end

data/spec/conjurize_spec.rb

@@ -1,70 +0,0 @@
-require "spec_helper"
-require "conjur/conjurize"
-
-describe Conjur::Conjurize do
-  let(:certificate) do
-    OpenSSL::X509::Certificate.new.tap do |cert|
-      key = OpenSSL::PKey::RSA.new 512
-      cert.public_key = key.public_key
-      cert.not_before = Time.now
-      cert.not_after = 1.minute.from_now
-      cert.sign key, OpenSSL::Digest::SHA256.new
-    end
-  end
-
-  let(:certfile) do
-    Tempfile.new("cert").tap do |file|
-      file.write certificate.to_pem
-      file.close
-    end
-  end
-
-  let(:host_id) { "somehostid" }
-  let(:api_key) { "very_secret_key" }
-  let(:account) { "testacct" }
-  let(:appliance_url) { "https://example.com" }
-
-  before do
-    allow(Conjur.config).to receive_messages \
-      account: account,
-      cert_file: certfile.path,
-      appliance_url: appliance_url
-  end
-
-  describe ".generate" do
-    it "puts all the relevant data in the script" do
-      script = Conjur::Conjurize.generate "id" => host_id, "api_key" => api_key
-      expect(script).to include host_id, api_key, account, certificate.to_pem
-    end
-
-    it "dumps JSON if required" do
-      allow(Conjur::Conjurize).to receive_messages options: { json: true }
-      expect(
-        JSON.load(
-          Conjur::Conjurize.generate(
-            "id" => host_id,
-            "api_key" => api_key
-          )
-        )
-      ).to eq \
-        "id" => host_id,
-        "api_key" => api_key,
-        "account" => account,
-        "certificate" => certificate.to_pem.strip,
-        "appliance_url" => appliance_url
-    end
-  end
-
-  describe ".configuration" do
-    it "gathers all the configuration options" do
-      expect(
-        Conjur::Conjurize.configuration("id" => host_id, "api_key" => api_key)
-      ).to eq \
-        "id" => host_id,
-        "api_key" => api_key,
-        "account" => account,
-        "certificate" => certificate.to_pem.strip,
-        "appliance_url" => appliance_url
-    end
-  end
-end

data/spec/dsl/runner_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-require 'conjur/dsl/runner'
-
-describe Conjur::DSL::Runner, logged_in: true do
-  include_context "fresh config"
-
-  let(:filename) { nil }
-  let(:runner) { Conjur::DSL::Runner.new script, filename }
-  before {
-    allow(Conjur).to receive(:account).and_return "the-account"
-    allow(runner).to receive(:api).and_return api
-  }
-  context "nil record ids" do
-    subject { runner.execute }
-    context "creating a user" do
-      let(:script) { "user" }
-      it "isn't allowed" do
-        expect{ subject }.to raise_error
-      end
-    end
-    context "creating a resource" do
-      let(:script) { "scope 'kitchen' do; resource 'food'; end" }
-      it "creates resource with id matching the scope" do
-        expect(api).to receive(:resource).with("the-account:food:kitchen").and_return double("kitchen-exists", :exists? => true)
-        subject
-      end
-    end
-    context "creating a layer" do
-      let(:script) { "scope 'kitchen' do; layer; end" }
-      it "creates layer with id matching the scope" do
-        expect(api).to receive(:layer).with("kitchen").and_return double("kitchen-exists", :exists? => true)
-        subject
-      end
-    end
-  end
-  context "creating user:alice" do
-    let(:script) { "user 'alice'" }
-    let(:alice) {
-      Conjur::User.new("alice").tap do |user|
-        user.attributes = { "api_key" => "the-api-key" }    
-      end
-    }
-    it "should populate the root ownerid" do
-      expect(api).to receive(:user).with("alice").and_return double("alice-exists", exists?: false)
-      expect(api).to receive(:create_user).with(id: "alice", ownerid: "user:bob").and_return alice
-      
-      runner.owner = "user:bob"
-      runner.execute
-    end
-    it "should store the api_key in the context keyed by roleid" do
-      expect(api).to receive(:user).with("alice").and_return double("alice-exists", exists?: false)
-      expect(api).to receive(:create_user).with(id: "alice").and_return alice
-      
-      runner.execute
-      
-      expect(runner.context['api_keys']).to eq({
-        "the-account:user:alice" => "the-api-key"
-      })
-    end
-  
-    it "doesn't store default env and stack in context" do
-      expect(runner.context).to_not have_key 'env'
-      expect(runner.context).to_not have_key 'stack'
-    end
-  
-    context "with non-default stack and env" do
-      let(:runner) do
-        Conjur::Config.merge env: 'baz', stack: 'bar'
-        Conjur::Config.apply
-        Conjur::DSL::Runner.new '', nil
-      end
-  
-      it "stores them in context" do
-        expect(runner.context['env']).to eq 'baz'
-        expect(runner.context['stack']).to eq 'bar'
-      end
-    end
-  
-    context "with appliance url" do
-      let(:appliance_url) { "https://conjur.example.com/api" }
-      let(:runner) do
-        Conjur::Config.merge appliance_url: appliance_url
-        Conjur::Config.apply
-        
-        Conjur::DSL::Runner.new '', nil
-      end
-  
-      it "stores appliance url in the context" do
-        expect(runner.context['appliance_url']).to eq appliance_url
-      end
-    end
-  end
-end

data/spec/env_spec.rb

@@ -1,214 +0,0 @@
-require 'spec_helper'
-require 'conjur/conjurenv'
-
-describe Conjur::Env do
-  describe Conjur::Env::ConjurVariable do
-    it "reports a missing value" do
-      var = Conjur::Env::ConjurVariable.new('the-id')
-      expect { var.evaluate nil }.to raise_error "variable the-id exists but doesn't have a value"
-    end
-  end
-
-  describe "#initialize" do
-
-    describe "requires either :file or :yaml parameter" do
-      before { 
-        expect_any_instance_of(Conjur::Env).not_to receive(:parse) 
-      }
-      it "fails if both options are provided" do
-        expect { Conjur::Env.new(file: 'f', yaml: 'y') }.to raise_error ":file and :yaml options can not be provided together"
-      end   
-      it "fails if neither option is provided" do  
-        expect { Conjur::Env.new() }.to raise_error "either :file or :yaml option is mandatory"
-      end
-      it "fails if :yaml option is empty or is not a string" do
-        expect { Conjur::Env.new(yaml: "") }.to raise_error ":yaml option should be non-empty string"
-        expect { Conjur::Env.new(yaml: nil) }.to raise_error ":yaml option should be non-empty string"
-        expect { Conjur::Env.new(yaml: 2) }.to raise_error ":yaml option should be non-empty string"
-      end
-      it "fails if :file option is empty or is not a string"do
-        expect { Conjur::Env.new(file: "") }.to raise_error ":file option should be non-empty string"
-        expect { Conjur::Env.new(file: nil) }.to raise_error ":file option should be non-empty string"
-        expect { Conjur::Env.new(file: 2) }.to raise_error ":file option should be non-empty string"
-      end
-    end
-
-    describe "with correct parameters" do
-
-      let(:parsed) { :parsed_structure_stub }
-
-      describe "if :file parameter provided" do
-        it "does not catch any errors from File.read" do
-          expect_any_instance_of(Conjur::Env).not_to receive(:parse) 
-          allow(File).to receive(:read).with('unexisting') { raise "Custom error" }
-          expect { Conjur::Env.new(file: 'unexisting') }.to raise_error "Custom error"
-        end 
-
-        it "if file is readable, passes contents to #parse and stores result in @definition attribute" do 
-          expect(File).to receive(:read).with("somefile").and_return(:file_contents) 
-          expect_any_instance_of(Conjur::Env).to receive(:parse).with(:file_contents).and_return(:stub_parsed) 
-          expect(Conjur::Env.new(file:"somefile").instance_variable_get("@definition")).to eq(:stub_parsed)
-        end
-      end
-      it "if :yaml parameter provided, passes it to #parse and stores result in @definition attribute" do
-        expect_any_instance_of(Conjur::Env).to receive(:parse).with("custom yaml").and_return(:stub_parsed)
-        expect(Conjur::Env.new(yaml:"custom yaml").instance_variable_get("@definition")).to eq(:stub_parsed)
-      end
-    end
-  end
-
-  describe "#parse (called from 'initialize')" do
-
-    it 'parses input as YAML and does not hide YAML errors' do
-      expect(YAML).to receive(:load).with("custom yaml") { raise "Custom error" }
-      expect { Conjur::Env.new(yaml: "custom yaml") }.to raise_error "Custom error"
-    end
-
-    it "fails unless YAML represents a Hash" do
-      expect { Conjur::Env.new(yaml: "[ 1,2,3 ]") }.to raise_error "Definition should be a Hash"
-    end
-
-    it "fails if values are not literal, number, !tmp or !var" do
-      expect { Conjur::Env.new(yaml: "{a: literal, b: !tmp tempfile, c: !var conjurvar, d: { x: another literal }}") }.to raise_error /^Definition can not include values of types/
-      expect { Conjur::Env.new(yaml: "{a: literal, b: 123, c: !tmp tempfile, d: !var conjurvar}") }.to_not raise_error 
-    end 
-
-    it 'does not allow empty values for !tmp and !var' do
-      expect { Conjur::Env.new(yaml: "{a: literal, b: !tmp , c: !var conjurvar }") }.to raise_error "ConjurTempfile requires a parameter"
-      expect { Conjur::Env.new(yaml: "{a: literal, b: !tmp tempfile, c: !var }") }.to raise_error "ConjurVariable requires a parameter"
-      expect { Conjur::Env.new(yaml: "{a: literal, b: !tmp tempfile, c: !var conjurvar}") }.to_not raise_error 
-    end
-
-    it "Returns hash consisting of literals, ConjurTempfile and ConjurVariable objects" do
-      result = Conjur::Env.new(yaml: "{a: literal, b: !tmp 'sometmp', c: !var 'somevar'}").instance_variable_get("@definition")
-      expect(result.keys.sort).to eq(["a","b","c"])
-      expect(result["a"]).to eq('literal')
-      expect(result["b"]).to be_a_kind_of(Conjur::Env::ConjurTempfile)
-      expect(result["b"].conjur_id).to eq('sometmp')
-      expect(result["c"]).to be_a_kind_of(Conjur::Env::ConjurVariable)
-      expect(result["c"].conjur_id).to eq('somevar')
-    end
-    
-    it "Accepts empty string substitution" do
-      substitutions = {
-      }
-      result = Conjur::Env.new(yaml: "{a: $foo, b: !tmp '$foo$foo$bar', c: !var '$foo$bar'}", substitutions: substitutions).instance_variable_get("@definition")
-      expect(result["a"]).to eq('$foo')
-      expect(result["b"].conjur_id).to eq('$foo$foo$bar')
-      expect(result["c"].conjur_id).to eq('$foo$bar')
-    end
-
-    it "Performs requested string substitution" do
-      substitutions = {
-        "$foo" => "alice",
-        "$bar" => "bob"
-      }
-      result = Conjur::Env.new(yaml: "{a: $foo, b: !tmp '$foo$foo$bar', c: !var '$foo$bar'}", substitutions: substitutions).instance_variable_get("@definition")
-      expect(result["a"]).to eq('alice')
-      expect(result["b"].conjur_id).to eq('alicealicebob')
-      expect(result["c"].conjur_id).to eq('alicebob')
-    end
-
-    it "Converts numbers to string literals" do
-      result = Conjur::Env.new(yaml: "{a: 123}").instance_variable_get("@definition")
-      expect(result["a"]).to eq("123")
-    end
-
-  end
-
-  describe "#obtain", logged_in: true do
-    let(:subject) { Conjur::Env.new(yaml: "{a: literal, b: !tmp tempfile, c: !var conjurvar}") }
-    before { 
-      allow(api).to receive(:variable_values).with(["tempfile","conjurvar"]).and_return({"tempfile" => "stubtemp", "conjurvar" => "stubvar" })
-    }
-
-    it "requests variable_values with list of !var and !tmp values" do    
-      allow_any_instance_of(Conjur::Env::ConjurTempfile).to receive(:evaluate).and_return(:stub_value) # avoid tempfiles creation
-      expect(api).to receive(:variable_values).with(["tempfile","conjurvar"]).and_return({"tempfile" => "stub1", "conjurvar" => "stub2" })
-      subject.obtain(api)
-    end
-
-    it 'does not suppress api errors' do  
-      allow(api).to receive(:variable_values) { raise "Custom API error" }
-      expect { subject.obtain(api) }.to raise_error "Custom API error" 
-    end
-
-    describe "for !tmp creates temporary files with Conjur variable value" do
-      it "in /dev/shm if it exists" do  
-        tempfile = double(path: '/dev/shm/newfile', close: true)
-        expect(File).to receive(:directory?).with("/dev/shm").and_return(true)
-        expect(File).to receive(:writable?).with("/dev/shm").and_return(true)
-        expect(Tempfile).to receive(:new).with("conjur","/dev/shm").and_return(tempfile)
-        expect(tempfile).to receive(:write).with("stubtemp")
-        subject.obtain(api)
-      end
-      it "otherwise uses Tempfile defaults" do
-        tempfile = double(path: '/tmp/newfile', close: true)
-        expect(File).to receive(:directory?).with("/dev/shm").and_return(false)
-        expect(Tempfile).to receive(:new).with("conjur").and_return(tempfile)
-        expect(tempfile).to receive(:write).with("stubtemp")
-        subject.obtain(api)
-      end
-    end
-
-    describe "returns hash consisting of original keys and following values" do
-      before {  
-        tempfile=double(path:"/stub/tempfile",write: true, close: true)
-        allow(File).to receive(:directory?).with("/dev/shm").and_return(true)
-        allow(File).to receive(:writable?).with("/dev/shm").and_return(true)
-        allow(Tempfile).to receive(:new).with("conjur","/dev/shm").and_return(tempfile)
-      }
-      let(:result) { subject.obtain(api) }
-
-      it 'literals' do
-        expect(result).to include("a"=>"literal") 
-      end
-      it '!tmp: names of temp files' do
-        expect(result).to include("b"=>"/stub/tempfile")
-      end
-      it '!var: variable values' do
-        expect(result).to include("c"=>"stubvar")
-      end
-    end
-  end
-
-  describe "#check", logged_in: true do
-
-    let(:subject) { Conjur::Env.new(yaml: "{a: literal, b: !tmp tempfile_b, c: !var conjurvar_c, d: !tmp tempfile_d, e: !var conjurvar_e }") }
-    before { 
-      expect(api).not_to receive(:variable_values) 
-      expect(Tempfile).not_to receive(:new)
-    }
-    let(:permitted)  { double(permitted?:true) }
-    let(:restricted) { double(permitted?:false) }
-
-    it "requests resource 'execute' permission for each !var and !tmp value" do
-      expect(api).to receive(:resource).with("variable:tempfile_b").and_return(permitted) 
-      expect(api).to receive(:resource).with("variable:conjurvar_c").and_return(permitted) 
-      expect(api).to receive(:resource).with("variable:tempfile_d").and_return(permitted) 
-      expect(api).to receive(:resource).with("variable:conjurvar_e").and_return(permitted) 
-      expect(permitted).to receive(:permitted?).exactly(4).times.with(:execute).and_return(true)
-      subject.check(api)
-    end
-
-    it 'does not rescue from unexpected api errors' do  
-      expect(api).to receive(:resource).with("variable:tempfile_b") { raise "Custom error" }
-      expect { subject.check(api) }.to raise_error "Custom error"
-    end
-
-    it "returns Hash consisting of original keys and following statuses: :literal, :available, :unavailable" do
-      expect(api).to receive(:resource).with("variable:tempfile_b").and_return(permitted) 
-      expect(api).to receive(:resource).with("variable:conjurvar_c").and_return(restricted) 
-      expect(api).to receive(:resource).with("variable:tempfile_d").and_return(restricted) 
-      expect(api).to receive(:resource).with("variable:conjurvar_e").and_return(permitted) 
-      
-      result = expect(subject.check(api)).to eq({ "a" => :literal, 
-                                              "b" => :available, 
-                                              "c" => :unavailable, 
-                                              "d" => :unavailable, 
-                                              "e" => :available 
-                                            })
-    end
-  end
-    
-end