crv_api_client 0.1.3

data/spec/lib/crv/helpers/crv_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe ::CrvApiClient::Helpers::Crv do
+  let(:tested_class) { Class.new { include ::CrvApiClient::Helpers::Crv }.new }
+  let(:participant_code) { '123' }
+  context 'get_keeper' do
+    it 'should return an ParticipatId class' do
+      expect(tested_class).to receive(:endpoint_participant_id).and_return(::CrvApiClient::Api::Animals::ParticipantId)
+      result = tested_class.get_keeper("123",nil)
+      expect(result).to be_an(::CrvApiClient::Api::Animals::ParticipantId)
+    end
+
+    it 'should return netherlands type when country is nil' do
+      expect(tested_class).to receive(:endpoint_participant_id).and_return(::CrvApiClient::Api::Animals::ParticipantId)
+
+      result = tested_class.get_keeper(participant_code,nil)
+      expect(result.countryCode).to eq("NLD")
+      expect(result.participantCode).to be(participant_code)
+      expect(result.participantCodeType).to eq("UBN")
+    end
+
+    it 'should return netherlands type when country is NL' do
+      expect(tested_class).to receive(:endpoint_participant_id).and_return(::CrvApiClient::Api::Animals::ParticipantId)
+
+      result = tested_class.get_keeper(participant_code,"nl")
+      expect(result.countryCode).to eq("NLD")
+      expect(result.participantCode).to be(participant_code)
+      expect(result.participantCodeType).to eq("UBN")
+    end
+
+    it 'should return german type when country is DE' do
+      expect(tested_class).to receive(:endpoint_participant_id).and_return(::CrvApiClient::Api::Animals::ParticipantId)
+
+      result = tested_class.get_keeper(participant_code,"DE")
+      expect(result.countryCode).to eq("DE")
+      expect(result.participantCode).to be(participant_code)
+      expect(result.participantCodeType).to eq("LDE")
+    end
+
+    it 'should return belgian type when country is BE' do
+      expect(tested_class).to receive(:endpoint_participant_id).and_return(::CrvApiClient::Api::Animals::ParticipantId)
+
+      result = tested_class.get_keeper(participant_code,"BE")
+      expect(result.countryCode).to eq("BE")
+      expect(result.participantCode).to be(participant_code)
+      expect(result.participantCodeType).to eq("UVN")
+    end
+
+    it 'should return czech type when country is CZ' do
+      expect(tested_class).to receive(:endpoint_participant_id).and_return(::CrvApiClient::Api::Animals::ParticipantId)
+
+      result = tested_class.get_keeper(participant_code,"CZ")
+      expect(result.countryCode).to eq("CZ")
+      expect(result.participantCode).to be(participant_code)
+      expect(result.participantCodeType).to eq("LCZ")
+    end
+  end
+
+  context :get_crv_organisation_code do
+
+    it 'should return netherlands crv code when country is nil' do
+      result = tested_class.get_crv_organisation_code nil
+      expect(result).to eq("crv.nl")
+    end
+
+    it 'should return netherlands crv code when country is NL' do
+      result = tested_class.get_crv_organisation_code "nl"
+      expect(result).to eq("crv.nl")
+    end
+
+    it 'should return german crv code when country is DE' do
+      result = tested_class.get_crv_organisation_code "DE"
+      expect(result).to eq("crv.de")
+    end
+
+    it 'should return belgian crv code when country is BE' do
+      result = tested_class.get_crv_organisation_code "BE"
+      expect(result).to eq("crv.be")
+    end
+  end
+
+  context 'perform_service_message_validation' do
+    it 'should throw an crv error on an error' do
+     serviceMessage = ::CrvApiClient::Api::Animals::ServiceMessage.new("200","200","some error","somme  type")
+     expect{tested_class.send(:perform_service_message_validation,serviceMessage)}.to raise_error(::CrvApiClient::Errors::CrvRequestError)
+    end
+
+    it 'should throw an crv error on an error on an Reproduction Service message' do
+      serviceMessage = ::CrvApiClient::Api::Reproduction::ServiceMessage.new("200","200","some error","somme  type")
+      expect{tested_class.send(:perform_service_message_validation,serviceMessage)}.to raise_error(::CrvApiClient::Errors::CrvRequestError)
+    end
+  end
+
+
+  context 'context_message' do
+    it 'should return a context message' do
+      username = "abc"
+      password = "efg"
+      keeper = ::CrvApiClient::Api::Reproduction::ParticipantId.new("a","b","c")
+      animalid = ::CrvApiClient::Api::Reproduction::AnimalId.new("b","c")
+      contextmessageDetail = [::CrvApiClient::Api::Reproduction::ContextMessageDetail.new("",""), ::CrvApiClient::Api::Reproduction::ContextMessageDetail.new("b","c")]
+      processCode = "102"
+      organisation = ::CrvApiClient::Api::Reproduction::ParticipantId.new("or","b","c")
+      crv_customer = ::CrvApiClient::Api::Reproduction::ParticipantId.new("10106605","PAR","NLD")
+      crv_provider = ::CrvApiClient::Api::Reproduction::ParticipantId.new("2323","test","asd")
+
+      expect(tested_class).to receive(:endpoint_context_message).and_return(::CrvApiClient::Api::Reproduction::ContextMessage)
+      message = tested_class.send(:context_message, keeper,
+                                       animal: animalid,
+                                       username: username,
+                                       password: password,
+                                       context_message_detail: contextmessageDetail,
+                                       process_code: processCode,
+                                       customer: crv_customer,
+                                       provider: crv_provider,
+                                       organisation: organisation)
+
+      expect(message.animal).to be(animalid)
+      expect(message.keeper).to be(keeper)
+      expect(message.contextMessageDetail).to be(contextmessageDetail)
+      expect(message.processCode).to be (processCode)
+      expect(message.username).to be(username)
+      expect(message.password).to be(password)
+      expect(message.organisation).to be(organisation)
+      expect(message.customer).to be(crv_customer)
+      expect(message.provider).to be(crv_provider)
+    end
+  end
+
+  context 'keeper_and_context_message_detail' do
+    it 'should return an keeper and context message' do
+      crv_id = 29
+      country_code = "NL"
+      keeper = ::CrvApiClient::Api::Reproduction::ParticipantId.new(crv_id,"",country_code)
+      expect(tested_class).to receive(:endpoint_context_message_detail).and_return(::CrvApiClient::Api::Reproduction::ContextMessageDetail)
+      expect(tested_class).to receive(:get_keeper).with(crv_id.to_s,country_code).and_return(keeper)
+
+      keeper, context_message = tested_class.send(:keeper_and_context_message_detail, crv_id, country_code)
+      expect(keeper).to be_a(::CrvApiClient::Api::Reproduction::ParticipantId)
+      expect(keeper).to eq(keeper)
+      expect(context_message).to be_a(::CrvApiClient::Api::Reproduction::ContextMessageDetail)
+    end
+  end
+
+end
+

data/spec/lib/crv/helpers/endpoint_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe ::CrvApiClient::Helpers::Endpoint do
+  CrvApiClient::Helpers.const_set("SomeClass", Class.new() { include ::CrvApiClient::Helpers::Endpoint } )
+  Object.const_set("NoModuleClass", Class.new() { include ::CrvApiClient::Helpers::Endpoint } )
+  let(:tested_class) { CrvApiClient::Helpers::SomeClass.new}
+  let(:animal_class) { CrvApiClient::Animals.new}
+  let(:reproduction_class) { CrvApiClient::Reproduction.new}
+
+  shared_examples 'endpoint resolver' do |klass_under_test,expected_klass, method|
+    it "and should create a #{expected_klass} from a #{klass_under_test}"  do
+      klass_instance = klass_under_test.new
+      klass_instance.extend(::CrvApiClient::Helpers::Endpoint)
+      expect(Object).to receive(:const_get).with(expected_klass.name).and_return(expected_klass.new)
+      klass = klass_instance.send(method)
+      expect(klass).to be_a(expected_klass)
+    end
+  end
+
+  context 'class_api_endpoint' do
+    it "should add the module api before the class name" do
+      result = tested_class.send(:class_api_endpoint)
+      expect(result).to eq("CrvApiClient::Helpers::Api::SomeClass::")
+    end
+
+    it "should return the class when namespace cant be found" do
+      result = NoModuleClass.new.send(:class_api_endpoint)
+      expect(result).to eq("NoModuleClass")
+    end
+  end
+
+
+  context 'endpoint_participant_id' do
+      it_behaves_like 'endpoint resolver' , CrvApiClient::Animals, CrvApiClient::Api::Animals::ParticipantId, :endpoint_participant_id
+      it_behaves_like 'endpoint resolver' , CrvApiClient::Reproduction, CrvApiClient::Api::Reproduction::ParticipantId, :endpoint_participant_id
+  end
+
+  context 'endpoint_context_message_detail' do
+    it_behaves_like 'endpoint resolver' , CrvApiClient::Animals, CrvApiClient::Api::Animals::ContextMessageDetail, :endpoint_context_message_detail
+    it_behaves_like 'endpoint resolver' , CrvApiClient::Reproduction, CrvApiClient::Api::Reproduction::ContextMessageDetail, :endpoint_context_message_detail
+  end
+
+  context 'endpoint_context_message' do
+    it_behaves_like 'endpoint resolver' , CrvApiClient::Animals, CrvApiClient::Api::Animals::ContextMessage, :endpoint_context_message
+    it_behaves_like 'endpoint resolver' , CrvApiClient::Reproduction, CrvApiClient::Api::Reproduction::ContextMessage, :endpoint_context_message
+  end
+
+  context 'endpoint_animal_id' do
+    it_behaves_like 'endpoint resolver' , CrvApiClient::Animals, CrvApiClient::Api::Animals::AnimalId, :endpoint_animal_id
+    it_behaves_like 'endpoint resolver' , CrvApiClient::Reproduction, CrvApiClient::Api::Reproduction::AnimalId, :endpoint_animal_id
+  end
+end
+
+

data/spec/lib/crv/reproduction_spec.rb

@@ -0,0 +1,137 @@
+describe CrvApiClient::Reproduction do
+  let(:endpoint) { "https://localhost/reproduction" }
+  let(:default_content_type) { 'application/json' }
+
+  let(:animal) {::CrvApiClient::Api::Reproduction::AnimalId.new("b","c")}
+  let(:config_customer) { {participant_code:"10106605",participant_code_type:"PAR", country_code:"NLD"} }
+  let(:config_provider) { {participant_code:"2323",participant_code_type:"test", country_code:"asd"} }
+  let(:crv_customer) { ::CrvApiClient::Api::Reproduction::ParticipantId.new("10106605","PAR","NLD")}
+  let(:crv_provider) { ::CrvApiClient::Api::Reproduction::ParticipantId.new("2323","test","asd")}
+  let(:username) {"Username"}
+  let(:password) {"password"}
+
+  let(:client) { CrvApiClient::Reproduction.new }
+  let(:configured_client) { ::CrvApiClient::Reproduction.new(endpoint, username: username, password: password, customer: config_customer, provider: config_provider ) }
+  context 'initialization' do
+
+    it "should initalize the client with given parameters" do
+      expect(configured_client.endpoint_url).to eq(endpoint)
+      expect(configured_client.username).to eq(username)
+      expect(configured_client.password).to eql(password)
+      expect(configured_client.customer).to be_a(::CrvApiClient::Api::Reproduction::ParticipantId)
+      expect(configured_client.provider).to be_a(::CrvApiClient::Api::Reproduction::ParticipantId)
+
+    end
+
+    it "should initialize with the configured attributes as default" do
+      CrvApiClient.configure do |conf|
+        conf.endpoint_reproduction = endpoint
+        conf.username = username
+        conf.password = password
+        conf.customer = config_customer
+      end
+
+      expect(client.endpoint_url).to eq(endpoint)
+      expect(client.username).to eq(username)
+      expect(client.password).to eq(password)
+      expect(client.customer).to be_a(::CrvApiClient::Api::Reproduction::ParticipantId)
+    end
+  end
+
+  context 'list_reproduction_last_parity' do
+    it 'should list animals' do
+      crv_id = 20
+      country_code  = "nl"
+      process_code = "2838"
+      context_message = CrvApiClient::Api::Reproduction::ContextMessage.new
+      keeper = ::CrvApiClient::Api::Reproduction::ParticipantId.new(crv_id,"",country_code)
+      context_message_detail = ::CrvApiClient::Api::Reproduction::ContextMessageDetail.new("a","b")
+      animal_request = CrvApiClient::Api::Reproduction::ParticipantAnimalRequest.new
+      animal_request_list = CrvApiClient::Api::Reproduction::ListParticipantAnimalRequest.new
+      requestType = CrvApiClient::Api::Reproduction::ListReproductionLastParityRequestType.new
+      service_message = ::CrvApiClient::Api::Reproduction::ServiceMessage
+      response = ::CrvApiClient::Api::Reproduction::ListReproductionLastParityResponse.new(nil,service_message)
+      driver = configured_client.send(:driver)
+
+      expect(configured_client).to receive(:keeper_and_context_message_detail).with(crv_id, country_code).and_return([keeper,context_message_detail]).once
+      expect(configured_client).to receive(:context_message).with(keeper, username: username, password: password, customer: instance_of(CrvApiClient::Api::Reproduction::ParticipantId), provider: instance_of(CrvApiClient::Api::Reproduction::ParticipantId), animal: nil, context_message_detail: context_message_detail,  process_code: process_code, organisation: nil).and_return(context_message).once
+      expect(configured_client).to receive(:participant_animal_request).with("TRP","PED").and_return(animal_request).once
+      expect(configured_client).to receive(:list_participant_animal_request).with("SHORT",[animal_request]).and_return(animal_request_list).once
+      expect(configured_client).to receive(:list_reproduction_last_parity_request_type).with(keeper,animal_request_list).and_return(requestType).once
+      expect(driver).to receive(:listReproductionLastParity).with(satisfy { |message|
+        expect(message).to be_a(CrvApiClient::Api::Reproduction::ListReproductionLastParityRequest)
+        expect(message.requestMessage).to be_a(CrvApiClient::Api::Reproduction::ListReproductionLastParityRequestType)
+        expect(message.requestMessage).to be(requestType)
+        expect(message.contextMessage).to be(context_message)
+      }).and_return(response).once
+      expect(configured_client).to receive(:perform_service_message_validation).with(service_message).once
+
+      configured_client.list_reproduction_last_parity(crv_id,country_code,process_code: process_code)
+
+    end
+
+    it 'should not handle message validations when option is given.' do
+      crv_id = 20
+      country_code  = "nl"
+      process_code = "2838"
+      context_message = CrvApiClient::Api::Reproduction::ContextMessage.new
+      keeper = ::CrvApiClient::Api::Reproduction::ParticipantId.new(crv_id,"",country_code)
+      context_message_detail = ::CrvApiClient::Api::Reproduction::ContextMessageDetail.new("a","b")
+      animal_request = CrvApiClient::Api::Reproduction::ParticipantAnimalRequest.new
+      animal_request_list = CrvApiClient::Api::Reproduction::ListParticipantAnimalRequest.new
+      requestType = CrvApiClient::Api::Reproduction::ListReproductionLastParityRequestType.new
+      service_message = ::CrvApiClient::Api::Reproduction::ServiceMessage
+      response = ::CrvApiClient::Api::Reproduction::ListReproductionLastParityResponse.new(nil,service_message)
+      driver = configured_client.send(:driver)
+
+      expect(configured_client).to receive(:keeper_and_context_message_detail).with(crv_id, country_code).and_return([keeper,context_message_detail]).once
+      expect(configured_client).to receive(:context_message).with(keeper, username: username, password: password, customer: instance_of(CrvApiClient::Api::Reproduction::ParticipantId), provider: instance_of(CrvApiClient::Api::Reproduction::ParticipantId), animal: nil, context_message_detail: context_message_detail,  process_code: process_code, organisation: nil).and_return(context_message).once
+      expect(configured_client).to receive(:participant_animal_request).with("TRP","PED").and_return(animal_request).once
+      expect(configured_client).to receive(:list_participant_animal_request).with("SHORT",[animal_request]).and_return(animal_request_list).once
+      expect(configured_client).to receive(:list_reproduction_last_parity_request_type).with(keeper,animal_request_list).and_return(requestType).once
+      expect(driver).to receive(:listReproductionLastParity).with(satisfy { |message|
+        expect(message).to be_a(CrvApiClient::Api::Reproduction::ListReproductionLastParityRequest)
+        expect(message.requestMessage).to be_a(CrvApiClient::Api::Reproduction::ListReproductionLastParityRequestType)
+        expect(message.requestMessage).to be(requestType)
+        expect(message.contextMessage).to be(context_message)
+      }).and_return(response).once
+      expect(configured_client).to receive(:perform_service_message_validation).with(service_message).never
+
+      response = configured_client.list_reproduction_last_parity(crv_id,country_code,process_code: process_code, options: {validate: false})
+    end
+  end
+
+  context 'list_reproduction_last_parity_request_type' do
+    it 'should create a new ListReproductionLastParityRequestType' do
+      keeper = ::CrvApiClient::Api::Reproduction::ParticipantId.new
+      participant_animal_request = CrvApiClient::Api::Reproduction::ListParticipantAnimalRequest.new
+      result = configured_client.send(:list_reproduction_last_parity_request_type, keeper,participant_animal_request)
+      expect(result).to be_a(CrvApiClient::Api::Reproduction::ListReproductionLastParityRequestType)
+      expect(result.keeper).to be(keeper)
+      expect(result.participantAnimalRequest).to be(participant_animal_request)
+    end
+  end
+
+  context 'list_participant_animal_request' do
+    it 'should create a new ListParticipantAnimalRequest' do
+      list_type = "SHORT"
+      participant_animal_request = CrvApiClient::Api::Reproduction::ParticipantAnimalRequest.new
+      result = configured_client.send(:list_participant_animal_request, list_type, participant_animal_request)
+      expect(result).to be_a(CrvApiClient::Api::Reproduction::ListParticipantAnimalRequest)
+      expect(result.listType).to be(list_type)
+      expect(result.participantAnimalRequest).to be(participant_animal_request)
+    end
+  end
+
+  context 'participant_animal_request' do
+    it 'should create a new ListParticipantAnimalRequest' do
+      number_type = "TRP"
+      number_sub_type= "PED"
+      result = configured_client.send(:participant_animal_request, number_type, number_sub_type)
+      expect(result).to be_a(CrvApiClient::Api::Reproduction::ParticipantAnimalRequest)
+      expect(result.numberType).to be(number_type)
+      expect(result.numberSubType).to be(number_sub_type)
+    end
+  end
+  
+end

data/spec/lib/crv_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe CrvApiClient do
+
+  describe "configure" do
+    it "should assign endpoints" do
+      animals = "EndpointAnimals"
+      reproduction = "EndpointReproduction"
+      result = CrvApiClient.configure do |config|
+        config.endpoint_animals = animals
+        config.endpoint_reproduction = reproduction
+      end
+
+      expect(CrvApiClient.configuration.endpoint_animals).to eq(animals)
+      expect(CrvApiClient.configuration.endpoint_reproduction).to eq(reproduction)
+
+      expect(result).to be_truthy
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'crv_api_client'
+
+require 'webmock/rspec'
+require 'vcr'
+
+
+VCR.configure do |c|
+  c.cassette_library_dir     = 'spec/fixtures/vcr'
+  c.hook_into                :webmock
+  c.ignore_localhost         = true
+  c.configure_rspec_metadata!
+end
+
+RSpec.configure do |config|
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+=end
+end

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification
+name: crv_api_client
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Nedap
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: soap4r-ruby1.9
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.1
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.10
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.10
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.18.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.18.0
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.2
+description: CRV API client
+email:
+- development-lm@nedap.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- crv_api_client.gemspec
+- lib/crv_api_client.rb
+- lib/crv_api_client/animals.rb
+- lib/crv_api_client/api.rb
+- lib/crv_api_client/api/animals.rb
+- lib/crv_api_client/api/animals/animals.rb
+- lib/crv_api_client/api/animals/animals_driver.rb
+- lib/crv_api_client/api/animals/animals_mapping_registry.rb
+- lib/crv_api_client/api/animals/rs_animal_service_client.rb
+- lib/crv_api_client/api/reproduction.rb
+- lib/crv_api_client/api/reproduction/esb_rs_reproduction_service_client.rb
+- lib/crv_api_client/api/reproduction/reproduction.rb
+- lib/crv_api_client/api/reproduction/reproduction_driver.rb
+- lib/crv_api_client/api/reproduction/reproduction_mapping_registry.rb
+- lib/crv_api_client/errors.rb
+- lib/crv_api_client/helpers.rb
+- lib/crv_api_client/helpers/attributes.rb
+- lib/crv_api_client/helpers/crv.rb
+- lib/crv_api_client/helpers/endpoint.rb
+- lib/crv_api_client/reproduction.rb
+- lib/crv_api_client/utils.rb
+- lib/crv_api_client/utils/configuration.rb
+- lib/crv_api_client/version.rb
+- spec/lib/crv/animals_spec.rb
+- spec/lib/crv/api/animals/animals_driver_spec.rb
+- spec/lib/crv/api/reproduction/reproduction_driver_spec.rb
+- spec/lib/crv/helpers/attributes_spec.rb
+- spec/lib/crv/helpers/crv_spec.rb
+- spec/lib/crv/helpers/endpoint_spec.rb
+- spec/lib/crv/reproduction_spec.rb
+- spec/lib/crv_spec.rb
+- spec/spec_helper.rb
+homepage: https://nedap.com
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.7.7
+signing_key:
+specification_version: 4
+summary: A Wrapper for the CRV soap API.
+test_files:
+- spec/lib/crv/animals_spec.rb
+- spec/lib/crv/api/animals/animals_driver_spec.rb
+- spec/lib/crv/api/reproduction/reproduction_driver_spec.rb
+- spec/lib/crv/helpers/attributes_spec.rb
+- spec/lib/crv/helpers/crv_spec.rb
+- spec/lib/crv/helpers/endpoint_spec.rb
+- spec/lib/crv/reproduction_spec.rb
+- spec/lib/crv_spec.rb
+- spec/spec_helper.rb