sbom-cyclonedx 0.1.0 → 0.2.0

data/spec/sbom/cyclone_dx/record/release_notes_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/release_notes"
+
+describe SBOM::CycloneDX::Record::ReleaseNotes do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:release_notes) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:release_notes, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/resource_reference_choice_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/resource_reference_choice"
+
+describe SBOM::CycloneDX::Record::ResourceReferenceChoice do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:resource_reference_choice) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:resource_reference_choice, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/risk_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/risk"
+
+describe SBOM::CycloneDX::Record::Risk do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:risk) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:risk, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/root_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/root"
+
+describe SBOM::CycloneDX::Record::Root do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:root) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:root, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/secured_by_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/secured_by"
+
+describe SBOM::CycloneDX::Record::SecuredBy do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:secured_by) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:secured_by, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/service_data_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/service_data"
+
+describe SBOM::CycloneDX::Record::ServiceData do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:service_data) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:service_data, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/service_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/service"
+
+describe SBOM::CycloneDX::Record::Service do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:service) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:service, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/signature_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/signature"
+
+describe SBOM::CycloneDX::Record::Signature do
+  describe SBOM::CycloneDX::Record::Signature::JSFSignature do
+    it "can be initialized with minimum required attributes" do
+      expect { build(:jsf_signature) }.not_to raise_error
+    end
+
+    it "can be initialized with all attributes" do
+      expect { build(:jsf_signature, :all_fields) }.not_to raise_error
+    end
+  end
+
+  describe SBOM::CycloneDX::Record::Signature::SignatureChain do
+    it "can be initialized with minimum required attributes" do
+      expect { build(:signature_chain) }.not_to raise_error
+    end
+
+    it "can be initialized with all attributes" do
+      expect { build(:signature_chain, :all_fields) }.not_to raise_error
+    end
+  end
+end

data/spec/sbom/cyclone_dx/record/standard_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/standard"
+
+describe SBOM::CycloneDX::Record::Standard do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:standard) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:standard, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/step_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/step"
+
+describe SBOM::CycloneDX::Record::Step do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:step) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:step, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/swid_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/swid"
+
+describe SBOM::CycloneDX::Record::SWID do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:swid) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:swid, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/task_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/task"
+
+describe SBOM::CycloneDX::Record::Task do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:task) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:task, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/tools_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/tools"
+
+describe SBOM::CycloneDX::Record::Tools do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:tools) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:tools, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/trigger_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/trigger"
+
+describe SBOM::CycloneDX::Record::Trigger do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:trigger) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:trigger, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/version_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/version"
+
+describe SBOM::CycloneDX::Record::Version do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:version) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:version, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/volume_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/volume"
+
+describe SBOM::CycloneDX::Record::Volume do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:volume) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:volume, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/vulnerability_source_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/vulnerability_source"
+
+describe SBOM::CycloneDX::Record::VulnerabilitySource do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:vulnerability_source) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:vulnerability_source, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/vulnerability_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/vulnerability"
+
+describe SBOM::CycloneDX::Record::Vulnerability do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:vulnerability) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:vulnerability, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/workflow_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/workflow"
+
+describe SBOM::CycloneDX::Record::Workflow do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:workflow) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:workflow, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record/workspace_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sbom/cyclone_dx/record/workspace"
+
+describe SBOM::CycloneDX::Record::Workspace do
+  it "can be initialized with minimum required attributes" do
+    expect { build(:workspace) }.not_to raise_error
+  end
+
+  it "can be initialized with all attributes" do
+    expect { build(:workspace, :all_fields) }.not_to raise_error
+  end
+end

data/spec/sbom/cyclone_dx/record_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe SBOM::CycloneDX::Record do
+  it "is just a module and so doesn't have real tests associated"
+end

data/spec/sbom/cyclone_dx/validator/array_validator_spec.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe SBOM::CycloneDX::Validator::ArrayValidator do
+  describe "#initialize" do
+    it "requires :items" do
+      expect { described_class.new(items: :string) }.not_to raise_error
+      # This may raise RBS::Test::Tester::TypeError or ArgumentError, depending on test context
+      expect { described_class.new }.to raise_error(Exception)
+    end
+  end
+
+  it "supports uniqueness checking" do
+    expect(described_class.new(items: :integer, unique: true).validate([1, 2, 3])).to be_empty
+    expect(described_class.new(items: :integer, unique: true).validate([1, 2, 2])).not_to be_empty
+  end
+
+  context "when :items is a symbol" do
+    let(:items) { :string }
+    let(:value) { %w[a bb ccc] }
+
+    describe "#initialize" do
+      it "accepts all symbols representing simple types" do
+        SBOM::CycloneDX::Validator::SIMPLE_TYPES.each do |simple_type|
+          expect { described_class.new(items: simple_type) }.not_to raise_error
+        end
+      end
+
+      it "rejects symbols that are not simple types" do
+        %i[array union record invalid].each do |invalid_type|
+          # This may raise RBS::Test::Tester::TypeError or ArgumentError, depending on test context
+          expect { described_class.new(items: invalid_type) }.to raise_error(Exception)
+        end
+      end
+    end
+
+    describe "#validate" do
+      subject(:instance) { described_class.new(items: items) }
+
+      it "does not permit nil elements" do
+        expect(instance.validate(value.push(nil).shuffle)).not_to be_empty
+      end
+
+      it "returns an empty array when all elements are of the specified type" do
+        expect(instance.validate(value)).to be_empty
+      end
+
+      it "returns an array of error messages when any element is not of the specified type" do
+        expect(instance.validate(value.push(1).shuffle)).not_to be_empty
+      end
+    end
+  end
+
+  context "when :items is a Class" do
+    let(:items) { SBOM::CycloneDX::Record::Property }
+    let(:value) { Array.new(rand(1..5)) { items.new(name: Faker::Lorem.word, value: Faker::Lorem.sentence) } }
+
+    describe "#initialize" do
+      it "accepts classes for Record types" do
+        expect { described_class.new(items: items) }.not_to raise_error
+      end
+
+      it "rejects classes that are not Record types" do
+        # This may raise RBS::Test::Tester::TypeError or ArgumentError, depending on test context
+        expect { described_class.new(items: String) }.to raise_error(Exception)
+      end
+    end
+
+    describe "#validate" do
+      subject(:instance) { described_class.new(items: items) }
+
+      it "does not permit nil elements" do
+        expect(instance.validate(value.push(nil).shuffle)).not_to be_empty
+      end
+
+      it "returns an empty array when all elements are of the specified type and valid" do
+        expect(instance.validate(value)).to be_empty
+      end
+
+      it "returns an array of error messages when any element is invalid" do
+        bad_items = [
+          SBOM::CycloneDX::Record::Declarations::Attestation::Map::Confidence.new(score: 0.1),
+          SBOM::CycloneDX::Record::Declarations::Attestation::Map::Confidence.new(score: 2.5),
+          SBOM::CycloneDX::Record::Declarations::Attestation::Map::Confidence.new(score: 0.9)
+        ]
+        confidence_instance =
+          described_class.new(items: SBOM::CycloneDX::Record::Declarations::Attestation::Map::Confidence)
+        expect(confidence_instance.validate(bad_items)).not_to be_empty
+      end
+
+      it "returns an array of error messages when any element is not of the specified type" do
+        value.push(SBOM::CycloneDX::Record::Copyright.new(text: Faker::Lorem.sentence))
+        expect(instance.validate(value)).not_to be_empty
+      end
+    end
+  end
+
+  context "when :items is an Array" do
+    let(:items) { [:string, min_length: 1, max_length: 2] }
+    let(:value) { %w[a bb cc] }
+
+    describe "#initialize" do
+      it "accepts an array representing validator creation arguments" do
+        expect { described_class.new(items: items) }.not_to raise_error
+      end
+
+      it "rejects an array that does not represent validator creation arguments" do
+        # This may raise RBS::Test::Tester::TypeError or ArgumentError, depending on test context
+        expect { described_class.new(items: %i[string integer]) }.to raise_error(Exception)
+      end
+    end
+
+    describe "#validate" do
+      subject(:instance) { described_class.new(items: items) }
+
+      it "does not permit nil elements by default" do
+        expect(instance.validate(value.push(nil).shuffle)).not_to be_empty
+      end
+
+      it "allows permitting nil elements" do
+        items.last[:required] = false
+        nilable_instance = described_class.new(items: items)
+        expect(nilable_instance.validate(value.push(nil).shuffle)).to be_empty
+      end
+
+      it "returns an empty array when all elements are valid" do
+        expect(instance.validate(value)).to be_empty
+      end
+
+      it "returns an array of error messages when any element is invalid" do
+        expect(instance.validate(value.push("dddd").shuffle)).not_to be_empty
+      end
+    end
+  end
+
+  # context "when :items is a Proc" do
+  #   pending "Re-implementation of procs in ArrayValidator"
+  #   let(:items) { ->(item) { item.even? && item < 10 } }
+  #   let(:value) { [2, 4, 6] }
+
+  #   describe "#initialize" do
+  #     it "accepts a Proc" do
+  #       expect { described_class.new(items: items) }.not_to raise_error
+  #     end
+  #   end
+
+  #   describe "#validate" do
+  #     subject(:instance) { described_class.new(items: items) }
+
+  #     it "returns proc return value when proc returns an array" do
+  #       expected_return = value.map { Faker::Lorem.word }
+  #       message_stack = expected_return.reverse
+  #       array_proc_instance = described_class.new(items: ->(_item) { message_stack.pop })
+  #       expect(array_proc_instance.validate(value)).to match_array(expected_return)
+  #     end
+
+  #     it "wraps proc value in array when proc returns a string" do
+  #       static_message = "some error message"
+  #       expected_return = value.map { static_message }
+  #       string_proc_instance = described_class.new(items: ->(_item) { static_message })
+  #       expect(string_proc_instance.validate(value)).to match_array(expected_return)
+  #     end
+
+  #     it "returns a basic error message when proc returns false" do
+  #       false_proc_instance = described_class.new(items: lambda(&:even?))
+  #       expect(false_proc_instance.validate([5])).to contain_exactly("5 is invalid")
+  #     end
+
+  #     it "returns an empty array when proc returns true" do
+  #       true_proc_instance = described_class.new(items: lambda(&:even?))
+  #       expect(true_proc_instance.validate([4])).to be_empty
+  #     end
+
+  #     it "returns an empty array when all elements are valid" do
+  #       expect(instance.validate(value)).to be_empty
+  #     end
+
+  #     it "returns an array of error messages when any element is invalid" do
+  #       expect(instance.validate(value.push(11).shuffle)).not_to be_empty
+  #     end
+  #   end
+  # end
+end

data/spec/sbom/cyclone_dx/validator/base_validator_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# This is a simple type validator, with no options
+describe SBOM::CycloneDX::Validator::BaseValidator do
+  subject(:validator_klass) { Class.new(described_class) }
+
+  describe "#initialize" do
+    it "returns an error if not subclassed" do
+      expect { described_class.new }.to raise_error(RuntimeError)
+    end
+
+    it "accepts optional class types" do
+      expect { validator_klass.new }.not_to raise_error
+      expect { validator_klass.new(Integer) }.not_to raise_error
+      expect { validator_klass.new(String, Float) }.not_to raise_error
+    end
+
+    it "accepts optional :required" do
+      expect(validator_klass.new).not_to be_required
+      expect(validator_klass.new(required: true)).to be_required
+    end
+  end
+
+  describe "#required?" do
+    it "returns true when initialized with required: true" do
+      expect(validator_klass.new(required: true).required?).to be true
+    end
+
+    it "returns false when intialized with required: false" do
+      expect(validator_klass.new(required: false).required?).to be false
+    end
+  end
+
+  describe "#valid?" do
+    subject(:validator) { validator_klass.new }
+
+    it "returns true when #validate returns no errors" do
+      allow(validator).to receive(:validate).and_return([]) # rubocop:disable RSpec/SubjectStub
+      expect(validator.valid?(1)).to be true
+    end
+
+    it "returns false when #validate returns errors" do
+      allow(validator).to receive(:validate).and_return(["some error"]) # rubocop:disable RSpec/SubjectStub
+      expect(validator.valid?(1)).to be false
+    end
+  end
+
+  describe "#validate" do
+    subject(:validator) { validator_klass.new(Integer, String) }
+
+    it "returns an empty array when the arg is one of the specified types" do
+      expect(validator.validate(1)).to eq []
+      expect(validator.validate("a")).to eq []
+    end
+
+    it "returns an error when the arg is not one of the specified types" do
+      expect(validator.validate(1.5)).to contain_exactly(an_instance_of(String))
+      expect(validator.validate(%w[a b c])).to contain_exactly(an_instance_of(String))
+    end
+
+    it "returns an empty array when the arg is nil and required is false" do
+      expect(validator_klass.new(Integer, required: false).validate(nil)).to eq []
+    end
+
+    it "returns an error when the arg is nil and required is true" do
+      expect(validator_klass.new(Integer, required: true).validate(nil)).to contain_exactly(an_instance_of(String))
+    end
+  end
+end

data/spec/sbom/cyclone_dx/validator/boolean_validator_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# This is a simple type validator, with no options
+describe SBOM::CycloneDX::Validator::BooleanValidator do
+  subject(:validator) { described_class.new(required: true) }
+
+  it "accepts true" do
+    expect(validator.validate(true)).to be_empty
+  end
+
+  it "accepts false" do
+    expect(validator.validate(false)).to be_empty
+  end
+
+  it "rejects truthy values" do
+    expect(validator.validate(1)).not_to be_empty
+    expect(validator.validate("true")).not_to be_empty
+  end
+
+  it "rejects falsey values" do
+    expect(validator.validate(0)).not_to be_empty
+    expect(validator.validate(nil)).not_to be_empty
+  end
+end

data/spec/sbom/cyclone_dx/validator/date_time_validator_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# This is a simple type validator, with no options
+describe SBOM::CycloneDX::Validator::DateTimeValidator do
+  subject(:validator) { described_class.new(required: true) }
+
+  it "accepts DateTime instances" do
+    expect(validator.validate(DateTime.current)).to be_empty
+  end
+
+  it "accepts Time instances" do
+    expect(validator.validate(Time.now)).to be_empty
+  end
+
+  it "accepts strings in ISO 8601 format" do
+    expect(validator.validate("2022-01-01T12:00:00Z")).to be_empty
+  end
+
+  it "rejects Date instances" do
+    expect(validator.validate(Date.today)).not_to be_empty
+  end
+
+  it "rejects strings in other formats" do
+    expect(validator.validate("6/15/2013, 5:32:17 PM")).not_to be_empty
+  end
+end

data/spec/sbom/cyclone_dx/validator/email_address_validator_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# This is a simple type validator, with no options
+describe SBOM::CycloneDX::Validator::EmailAddressValidator do
+  subject(:validator) { described_class.new(required: true) }
+
+  it "accepts EmailAddress instances" do
+    expect(validator.validate(EmailAddress::Address.new(Faker::Internet.email))).to be_empty
+  end
+
+  it "accepts strings representing valid email addresses" do
+    expect(validator.validate(Faker::Internet.email)).to be_empty
+  end
+
+  it "rejects strings representing invalid email addresses" do
+    expect(validator.validate("bad@email")).not_to be_empty
+    expect(validator.validate("bad.email")).not_to be_empty
+    expect(validator.validate("bad@.com")).not_to be_empty
+    expect(validator.validate("bad.com")).not_to be_empty
+  end
+end