nucleus 0.1.0

data/spec/unit/models/vendor_spec.rb

@@ -0,0 +1,100 @@
+require 'spec/unit/unit_spec_helper'
+
+describe Nucleus::Vendor do
+  let(:id) { '12345' }
+  let(:name) { 'fake vendor name' }
+  let(:created_at) { Time.now }
+  let(:updated_at) { Time.now.to_s }
+
+  describe 'can be initialized with' do
+    context 'an empty hash and' do
+      before do
+        @vendor = Nucleus::Vendor.new({})
+      end
+      it 'providers are empty' do
+        expect(@vendor.providers).to eql([])
+      end
+      it 'fields are empty' do
+        expect(@vendor.id).to be_nil
+        expect(@vendor.name).to be_nil
+        expect(@vendor.created_at).to be_nil
+        expect(@vendor.updated_at).to be_nil
+      end
+      it 'to_s does not crash' do
+        expect { @vendor.to_s }.to_not raise_error
+      end
+    end
+
+    context 'nil and' do
+      before do
+        @vendor = Nucleus::Vendor.new
+      end
+      it 'providers are empty' do
+        expect(@vendor.providers).to eql([])
+      end
+      it 'fields are empty' do
+        expect(@vendor.id).to be_nil
+        expect(@vendor.name).to be_nil
+        expect(@vendor.created_at).to be_nil
+        expect(@vendor.updated_at).to be_nil
+      end
+      it 'to_s does not crash' do
+        expect { @vendor.to_s }.to_not raise_error
+      end
+    end
+
+    context 'hash properties and provider double' do
+      before do
+        provider = instance_double('Nucleus::Provider', name: 'provider name')
+        allow(provider).to receive(:is_a?).with(Nucleus::Provider).and_return(true)
+        @vendor = Nucleus::Vendor.new('providers' => [provider], 'id' => id, 'name' => name,
+                                     'created_at' => created_at, 'updated_at' => updated_at)
+      end
+      it 'has one provider' do
+        expect(@vendor.providers).to_not eql([])
+        expect(@vendor.providers.length).to eql(1)
+      end
+      it 'fields are not nil' do
+        expect(@vendor.id).to_not be_nil
+        expect(@vendor.name).to_not be_nil
+      end
+      it 'dates wont be applied' do
+        expect(@vendor.created_at).to be_nil
+        expect(@vendor.updated_at).to be_nil
+      end
+      it 'fields have the valid values assigned' do
+        expect(@vendor.id).to eql(id)
+        expect(@vendor.name).to eql(name)
+      end
+      it 'to_s does not crash' do
+        expect { @vendor.to_s }.to_not raise_error
+      end
+    end
+
+    context 'hash properties and provider hash' do
+      before do
+        @vendor = Nucleus::Vendor.new('providers' => [{ 'name' => 'provider name' }], 'id' => id, 'name' => name,
+                                     'created_at' => created_at, 'updated_at' => updated_at)
+      end
+      it 'has one provider' do
+        expect(@vendor.providers).to_not eql([])
+        expect(@vendor.providers.length).to eql(1)
+      end
+      it 'fields are not nil' do
+        expect(@vendor.id).to_not be_nil
+        expect(@vendor.name).to_not be_nil
+      end
+      it 'dates wont be applied' do
+        expect(@vendor.created_at).to be_nil
+        expect(@vendor.updated_at).to be_nil
+      end
+      it 'fields have the valid values assigned' do
+        expect(@vendor.id).to eql(id)
+        expect(@vendor.name).to eql(name)
+      end
+      it 'to_s does not crash' do
+        expect { @vendor.to_s }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/unit/schemas/adapter_schema_spec.rb

@@ -0,0 +1,16 @@
+require 'spec/unit/unit_spec_helper'
+require 'kwalify'
+
+describe 'YAML adapter schema' do
+  before :all do
+    meta_validator = Kwalify::MetaValidator.instance
+    @parser = Kwalify::Yaml::Parser.new(meta_validator)
+  end
+
+  it 'does not produce errors' do
+    # NOTE may not work with different working dir
+    @parser.parse_file(File.expand_path('schemas/api.adapter.schema.yml'))
+    errors = @parser.errors
+    expect(errors).to match_array([])
+  end
+end

data/spec/unit/schemas/adapter_validation_spec.rb

@@ -0,0 +1,56 @@
+require 'spec/unit/unit_spec_helper'
+require 'kwalify'
+
+describe 'Nucleus::Adapters' do
+  Nucleus::VersionDetector.api_versions.each do |api_version|
+    describe "API #{api_version}" do
+      it 'has valid adapter requirements' do
+        expect(Nucleus::API.requirements(api_version)).to_not be_nil
+      end
+
+      describe 'configuration' do
+        Nucleus::Adapters.configuration_files.each do |file|
+          adapter_clazz = Nucleus::Adapters.adapter_clazz(file, api_version)
+          # adapter must not be available for each version (!)
+          next unless adapter_clazz
+          describe File.basename(file) do
+            it 'is a valid adapter configuration' do
+              expect(Nucleus::VendorParser.parse(file)).to_not be_nil
+            end
+
+            let!(:adapter) { adapter_clazz.new 'https://api.example.org' }
+            if Nucleus::API.requirements(api_version)
+              Nucleus::API.requirements(api_version).methods.each do |required_method|
+                describe "method #{required_method.name}" do
+                  it 'is implemented' do
+                    expect(adapter).to respond_to(required_method.name)
+                  end
+                  it 'has required arity' do
+                    expect(adapter).to respond_to(required_method.name).with(required_method.arguments).arguments
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      describe 'adapter stub' do
+        stub_clazz = Object.const_get('Nucleus').const_get('Adapters').const_get(api_version.upcase).const_get('Stub')
+        let!(:adapter) { stub_clazz.new 'https://api.example.org' }
+        if Nucleus::API.requirements(api_version)
+          Nucleus::API.requirements(api_version).methods.each do |required_method|
+            describe "method #{required_method.name}" do
+              it 'is implemented' do
+                expect(adapter).to respond_to(required_method.name)
+              end
+              it 'has required arity' do
+                expect(adapter).to respond_to(required_method.name).with(required_method.arguments).arguments
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/schemas/requirements_schema_spec.rb

@@ -0,0 +1,16 @@
+require 'spec/unit/unit_spec_helper'
+require 'kwalify'
+
+describe 'YAML requirements schema' do
+  before :all do
+    meta_validator = Kwalify::MetaValidator.instance
+    @parser = Kwalify::Yaml::Parser.new(meta_validator)
+  end
+
+  it 'does not produce errors' do
+    # NOTE may not work with different working dir
+    @parser.parse_file(File.expand_path('schemas/api.requirements.schema.yml'))
+    errors = @parser.errors
+    expect(errors).to match_array([])
+  end
+end

data/spec/unit/unit_spec_helper.rb

@@ -0,0 +1,11 @@
+require 'spec/spec_helper'
+require 'memfs'
+
+# define test suite for coverage report
+SimpleCov.command_name 'spec:suite:unit'
+
+RSpec.configure do |c|
+  c.around(:each, memfs: true) do |example|
+    MemFs.activate { example.run }
+  end
+end

data/tasks/compatibility.rake

@@ -0,0 +1,113 @@
+require 'rspec/core/rake_task'
+
+namespace :evaluation do
+  namespace :compatibility do
+    task load: :environment do
+      # TODO: choose API version
+      api_version = 'v1'
+      stub = Nucleus::Adapters.const_get(api_version.upcase).const_get('Stub').new 'https://api.example.org'
+
+      adapter_dao = Nucleus::API::DB::AdapterDao.instance(api_version)
+      endpoint_dao = Nucleus::API::DB::EndpointDao.instance(api_version)
+      provider_dao = Nucleus::API::DB::ProviderDao.instance(api_version)
+      vendor_dao = Nucleus::API::DB::VendorDao.instance(api_version)
+      @vendor_results = {}
+
+      adapter_dao.all.each do |adapter_index_entry|
+        vendor_name = vendor_dao.get(provider_dao.get(endpoint_dao.get(adapter_index_entry.id).provider).vendor).name
+        next if @vendor_results.key?(vendor_name)
+        adapter_results = {}
+        adapter = adapter_index_entry.adapter_clazz.new('https://api.example.org', 'http://apps.example.org', true)
+        stub.public_methods(false).each do |method_name|
+          args = []
+          method = stub.method(method_name)
+          method.arity.times { |time| args.push(time) }
+          begin
+            adapter.send(method_name, *args)
+            implemented = true
+          rescue Nucleus::Errors::AdapterMissingImplementationError
+            implemented = false
+          rescue StandardError
+            implemented = true
+          end
+          adapter_results[method_name] = implemented
+        end
+        @vendor_results[vendor_name] = adapter_results
+      end
+    end
+
+    task markdown: :load do
+      # table header
+      puts "Method / Vendor|#{@vendor_results.keys.join('|')}"
+
+      # column styles
+      alignment = ':--'
+      @vendor_results.length.times { |_time| alignment << '|:-:' }
+      puts alignment
+
+      lines = []
+      @vendor_results.each do |_vendor, results|
+        results.each_with_index do |(method, supported), line|
+          lines[line] = "#{method}" unless lines[line]
+          lines[line] << "|#{supported ? '&#10003;' : '&#10007;'}"
+        end
+      end
+
+      lines.each do |line|
+        puts line
+      end
+    end
+
+    task :latex, [:save_to] => :load do |_t, args|
+      all_lines = []
+      all_lines << "\\begin{longtable}{|L{7cm}|#{'c|' * @vendor_results.length}}"
+      next_line = '  \\multicolumn{1}{l}{\\Large{\\textbf{Adapter compatibility}}}'
+      @vendor_results.keys.each do |vendor|
+        next_line += " & \\multicolumn{1}{l}{\\turn{60}{#{vendor}}}"
+      end
+      next_line += ' \\\\\\hline'
+      all_lines << next_line
+      all_lines << '  \\endhead'
+      all_lines << '  \\rowcolor{white}'
+      all_lines << '  \\caption{List of methods that are supported by Nucleus per vendor}'\
+        '\\label{table:evaluation_adapter_compatibility}%'
+      all_lines << '  \\endlastfoot'
+
+      lines = []
+      @vendor_results.each do |_vendor, results|
+        results.each_with_index do |(method, supported), line|
+          lines[line] = "#{method}" unless lines[line]
+          lines[line] << " & #{supported ? '\\ding{51}' : '\\cellcolor{failedtablebg}\\ding{55}'}"
+        end
+      end
+
+      # format and print all lines
+      lines.each_with_index do |line, index|
+        if index != lines.length - 1
+          all_lines << "  #{line.gsub(/_/, '\_')} \\\\\\hline"
+        else
+          # special treatment for the last line
+          all_lines << "  #{line.gsub(/_/, '\_')} \\\\\\hhline{|=|#{'=|' * @vendor_results.length}}"
+        end
+      end
+
+      # print general statistics
+      total_methods = @vendor_results.collect { |_v, tests| tests.length }.uniq.first
+      supported_count = @vendor_results.collect { |_v, tests| tests.find_all { |_m, s| s }.length }
+      all_lines << "  Supported methods & #{supported_count.join(' & ')} \\\\\\hline"
+      to_print = supported_count.collect do |supported|
+        "#{format('%g', format('%.1f', (supported / total_methods.to_f * 100)))} \\%"
+      end
+
+      all_lines << "  Supported degree & #{to_print.join(' & ')} \\\\\\hline"
+
+      all_lines << '\\end{longtable}'
+
+      # print lines
+      all_lines.each { |line| puts line }
+
+      # and save to file if requested
+      File.open(args.save_to, 'w') { |file| file.write all_lines.join("\n") } if args.save_to
+    end
+  end
+end

data/tasks/evaluation.rake

@@ -0,0 +1,162 @@
+require 'rspec/core/rake_task'
+require 'oj'
+
+namespace :evaluation do
+  namespace :requests do
+    namespace :count do
+      desc 'Load the data that will be used in the request evaluation tasks'
+      task load: :environment do
+        # TODO: choose API version
+        api_version = 'v1'
+
+        adapter_dao = Nucleus::API::DB::AdapterDao.instance(api_version)
+        endpoint_dao = Nucleus::API::DB::EndpointDao.instance(api_version)
+        provider_dao = Nucleus::API::DB::ProviderDao.instance(api_version)
+        vendor_dao = Nucleus::API::DB::VendorDao.instance(api_version)
+        @vendor_results = {}
+
+        adapter_dao.all.each do |adapter_index_entry|
+          vendor_name = vendor_dao.get(provider_dao.get(endpoint_dao.get(adapter_index_entry.id).provider).vendor).name
+          # from camel to sneak case
+          adapter_file_name = vendor_name.gsub(/\s/, '_').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                              .gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+          next if @vendor_results.key?(vendor_name)
+          adaper_results = {}
+
+          method_recordings_dir = File.join('spec', 'adapter', 'recordings', api_version, adapter_file_name,
+                                            'vcr_cassettes', 'with_valid_credentials', 'is_compliant_and')
+          Find.find(method_recordings_dir) do |file|
+            next if File.directory?(file) || File.basename(file) == '.DS_Store'
+            test = Pathname.new(file).relative_path_from(Pathname.new(method_recordings_dir)).to_s
+            # Load contents with the serializer, oj
+            cassette = ::Oj.load(File.read(file))
+            adaper_results[test] = cassette['http_interactions'].length
+          end
+          @vendor_results[vendor_name] = adaper_results
+        end
+
+        @all_tests = @vendor_results.flat_map { |_name, tests| tests.keys }.uniq
+      end
+
+      task markdown: :load do
+        # table header
+        puts "Test / Vendor|#{@vendor_results.keys.join('|')}"
+
+        # column styles
+        alignment = ':--'
+        @vendor_results.length.times { |_time| alignment << '|:-:' }
+        puts alignment
+
+        lines = []
+        @all_tests.sort.each_with_index do |test_name, line|
+          @vendor_results.each do |_vendor, results|
+            lines[line] = "#{test_name}" unless lines[line]
+            lines[line] << "|#{results[test_name]}"
+          end
+        end
+
+        lines.each do |line|
+          puts line
+        end
+
+        # table header
+        puts '|' * @vendor_results.length
+        puts "Test / Vendor|#{@vendor_results.keys.join('|')}"
+        puts '|' * @vendor_results.length
+        puts "Tested methods|#{@vendor_results.collect { |_name, tests| tests.length }.join('|')}"
+        puts "Total vendor API requests|#{@vendor_results.collect do |_name, tests|
+          tests.map { |_key, value| value }.sum
+        end.join('|')}"
+        puts "Avg. vendor API requests per tested method|#{@vendor_results.collect do |_name, tests|
+          ((tests.map { |_key, value| value }.sum) / tests.length.to_f).round(2)
+        end.join('|')}"
+      end
+
+      task :latex, [:save_to] => :load do |_t, args|
+        tests_with_wait = %w(app-actions/lifecycle/restart/succeeds
+                             app-actions/lifecycle/start/succeeds_for_app_all_if_currently_stopped
+                             app-actions/lifecycle/start/succeeds_for_app_min_if_currently_stopped
+                             app-actions/lifecycle/stop/succeeds_for_app_all_if_currently_running
+                             app-actions/lifecycle/stop/succeeds_for_app_min_if_currently_running
+                             app-data/deploy/succeeds/and_app_with
+                             app-data/rebuild/changes_the_release_version_property
+                             app/web access/for_app_with_min_properties)
+        ignore_tests_with_wait = 0
+        ignore_req_with_wait = {}
+        @vendor_results.each { |vendor, _| ignore_req_with_wait[vendor] = 0 }
+
+        table = []
+        table << '\\scriptsize'
+        table << "\\begin{longtable}{|L{12cm}|#{'c|' * @vendor_results.length}}"
+        next_line = '  \\multicolumn{1}{l}{\\Large{\\textbf{recorded test cassette}}}'
+        @vendor_results.keys.each do |vendor|
+          next_line += " & \\multicolumn{1}{l}{\\turn{60}{#{vendor}}}"
+        end
+        next_line += ' \\\\\\hline'
+        table << next_line
+        table << '  \\endhead'
+        table << '  \\rowcolor{white}'
+        table << '  \\caption{Requests per method test case for all vendors}'\
+          '\\label{table:evaluation_request_count}%'
+        table << '  \\endlastfoot'
+
+        lines = []
+        @all_tests.sort.each_with_index do |t_name, line|
+          @vendor_results.each do |v, results|
+            unless lines[line]
+              lines[line] = "#{t_name}"
+              if tests_with_wait.any? { |name| t_name.start_with?(name) }
+                ignore_tests_with_wait += 1
+                lines[line] = "\\rowcolor{failedtablebg}#{lines[line]}"
+              end
+            end
+            ignore_req_with_wait[v] += results[t_name].to_i if tests_with_wait.any? { |name| t_name.start_with?(name) }
+            lines[line] << " & #{results[t_name]}"
+          end
+        end
+
+        # format and print all lines
+        lines.each_with_index do |line, index|
+          if index != lines.length - 1
+            table << "  #{line.gsub(/_/, '\_')} \\\\\\hline"
+          else
+            # special treatment for the last line
+            table << "  #{line.gsub(/_/, '\_')} \\\\\\hhline{|=|#{'=|' * @vendor_results.length}}"
+          end
+        end
+
+        # print general statistics
+        table << "  Tested methods & #{@vendor_results.collect { |_n, tests| tests.length }.join(' & ')} \\\\\\hline"
+        table << "  Total vendor API requests & #{@vendor_results.collect do |_name, tests|
+          tests.map { |_key, value| value }.sum
+        end.join(' & ')} \\\\\\hline"
+        table << "  Avg. vendor API requests per tested method & #{@vendor_results.collect do |_name, tests|
+          ((tests.map { |_key, value| value }.sum) / tests.length.to_f).round(2)
+        end.join(' & ')} \\\\\\hhline{|=|#{'=|' * @vendor_results.length}}"
+
+        # sanitize stats, exclude methods with rspec wait repetitions
+        table << "  Tested methods without repeated requests & #{@vendor_results.collect do |_n, tests|
+          tests.length - ignore_tests_with_wait
+        end.join(' & ')} \\\\\\hline"
+
+        table << "  Total vendor API requests without repeated requests & #{@vendor_results.collect do |name, tests|
+          tests.map { |_key, value| value }.sum - ignore_req_with_wait[name]
+        end.join(' & ')} \\\\\\hline"
+        table << '  Avg. vendor API requests per tested method without repeated requests & '\
+          "#{@vendor_results.collect do |name, tests|
+            ((tests.map { |_key, value| value }.sum - ignore_req_with_wait[name]) /
+            (tests.length - ignore_tests_with_wait).to_f).round(2)
+          end.join(' & ')} \\\\\\hline"
+
+        table << '\\end{longtable}'
+        table << '\\normalsize'
+
+        # print lines
+        table.each { |line| puts line }
+
+        # and save to file if requested
+        File.open(args.save_to, 'w') { |file| file.write table.join("\n") } if args.save_to
+      end
+    end
+  end
+end