sbom-cyclonedx 0.1.0 → 0.2.0

data/spec/sbom/cyclone_dx/validator/float_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::FloatValidator do
+  subject(:validator) { described_class.new(required: true) }
+
+  let(:value) { Faker::Number.decimal }
+
+  it "accepts Float objects" do
+    expect(validator.validate(value)).to be_empty
+  end
+
+  it "rejects other number-like objects" do
+    expect(validator.validate(value.to_c)).not_to be_empty
+    expect(validator.validate(value.to_i)).not_to be_empty
+    expect(validator.validate(value.to_r)).not_to be_empty
+    expect(validator.validate(value.to_s)).not_to be_empty
+  end
+
+  context "with constraints" do
+    let(:minimum) { Faker::Number.decimal }
+    let(:maximum) { minimum + Faker::Number.decimal.abs }
+
+    it "accepts values greater than or equal to a specified minimum" do
+      validator = described_class.new(minimum: minimum, required: true)
+
+      expect(validator.validate(minimum)).to be_empty
+      expect(validator.validate(minimum + 1)).to be_empty
+    end
+
+    it "accepts values less than or equal to a specified maximum" do
+      validator = described_class.new(maximum: maximum, required: true)
+
+      expect(validator.validate(maximum)).to be_empty
+      expect(validator.validate(maximum - 1)).to be_empty
+    end
+
+    it "accepts values within the range indicated by both minimum and maxiumum" do
+      validator = described_class.new(minimum: minimum, maximum: maximum, required: true)
+
+      expect(validator.validate(minimum)).to be_empty
+      expect(validator.validate(maximum)).to be_empty
+      expect(validator.validate((minimum + maximum) / 2)).to be_empty
+    end
+
+    it "rejects values less than the specified minimum" do
+      validator = described_class.new(minimum: minimum, required: true)
+
+      expect(validator.validate(minimum - 1)).not_to be_empty
+    end
+
+    it "rejects values greater than the specified maximum" do
+      validator = described_class.new(maximum: maximum, required: true)
+
+      expect(validator.validate(maximum + 1)).not_to be_empty
+    end
+
+    it "rejects values outside the range indicated by both minimum and maximum" do
+      validator = described_class.new(minimum: minimum, maximum: maximum, required: true)
+
+      expect(validator.validate(minimum - 1)).not_to be_empty
+      expect(validator.validate(maximum + 1)).not_to be_empty
+    end
+
+    it "raises an error if maximum is less than minimum" do
+      expect { described_class.new(minimum: maximum, maximum: minimum, required: true) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/sbom/cyclone_dx/validator/integer_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::IntegerValidator do
+  subject(:validator) { described_class.new(required: true) }
+
+  let(:value) { Faker::Number.number }
+
+  it "accepts Integer objects" do
+    expect(validator.validate(value)).to be_empty
+  end
+
+  it "rejects other number-like objects" do
+    expect(validator.validate(value.to_c)).not_to be_empty
+    expect(validator.validate(value.to_f)).not_to be_empty
+    expect(validator.validate(value.to_r)).not_to be_empty
+    expect(validator.validate(value.to_s)).not_to be_empty
+  end
+
+  context "with constraints" do
+    let(:minimum) { Faker::Number.number }
+    let(:maximum) { minimum + Faker::Number.positive.to_i }
+
+    it "accepts values greater than or equal to a specified minimum" do
+      validator = described_class.new(minimum: minimum, required: true)
+
+      expect(validator.validate(minimum)).to be_empty
+      expect(validator.validate(minimum + 1)).to be_empty
+    end
+
+    it "accepts values less than or equal to a specified maximum" do
+      validator = described_class.new(maximum: maximum, required: true)
+
+      expect(validator.validate(maximum)).to be_empty
+      expect(validator.validate(maximum - 1)).to be_empty
+    end
+
+    it "accepts values within the range indicated by both minimum and maxiumum" do
+      validator = described_class.new(minimum: minimum, maximum: maximum, required: true)
+
+      expect(validator.validate(minimum)).to be_empty
+      expect(validator.validate(maximum)).to be_empty
+      expect(validator.validate((minimum + maximum) / 2)).to be_empty
+    end
+
+    it "rejects values less than the specified minimum" do
+      validator = described_class.new(minimum: minimum, required: true)
+
+      expect(validator.validate(minimum - 1)).not_to be_empty
+    end
+
+    it "rejects values greater than the specified maximum" do
+      validator = described_class.new(maximum: maximum, required: true)
+
+      expect(validator.validate(maximum + 1)).not_to be_empty
+    end
+
+    it "rejects values outside the range indicated by both minimum and maximum" do
+      validator = described_class.new(minimum: minimum, maximum: maximum, required: true)
+
+      expect(validator.validate(minimum - 1)).not_to be_empty
+      expect(validator.validate(maximum + 1)).not_to be_empty
+    end
+
+    it "raises an error if maximum is less than minimum" do
+      expect { described_class.new(minimum: maximum, maximum: minimum, required: true) }.to raise_error(ArgumentError)
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# This is a simple type validator, with no options
+describe SBOM::CycloneDX::Validator::RecordValidator do
+  subject(:validator) { described_class.new(type: value.class, required: true) }
+
+  let(:value) { build(:note) }
+
+  it "accepts records with the correct type" do
+    expect(validator.validate(value)).to be_empty
+  end
+
+  it "rejects records with an incorrect type" do
+    bad_value = build(:parameter)
+    expect(validator.validate(bad_value)).not_to be_empty
+  end
+
+  it "validates simple fields" do
+    value.locale = "en-US"
+    expect(validator.validate(value)).to be_empty
+
+    value.locale = "what is this nonsense"
+    expect(validator.validate(value)).not_to be_empty
+  end
+
+  it "validates nested records" do
+    value.text.content_type = "text/json"
+    expect(validator.validate(value)).to be_empty
+
+    value.text.content_type = "what is this nonsense"
+    expect(validator.validate(value)).not_to be_empty
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# This is a simple type validator, with no options
+describe SBOM::CycloneDX::Validator::StringValidator do
+  subject(:validator) { described_class.new(required: true) }
+
+  let(:value) { Faker::Lorem.word }
+
+  it "accepts String objects" do
+    expect(validator.validate(value)).to be_empty
+  end
+
+  it "rejects other objects" do
+    expect(validator.validate(0)).not_to be_empty
+  end
+
+  context "with enum" do
+    subject(:validator) { described_class.new(enum: enum, required: true) }
+
+    let(:enum) { Array.new(3) { Faker::Lorem.word } }
+
+    it "accepts values in the enum" do
+      enum.each do |value|
+        expect(validator.validate(value)).to be_empty
+      end
+    end
+
+    it "rejects values not in the enum" do
+      expect(validator.validate(enum.join)).not_to be_empty
+    end
+  end
+
+  context "with length constraints" do
+    let(:min_length) { Faker::Number.number(digits: 2) }
+    let(:max_length) { min_length + Faker::Number.number(digits: 2).to_i }
+
+    it "accepts values with length greater than or equal to a specified min_length" do
+      validator = described_class.new(min_length: min_length, required: true)
+
+      expect(validator.validate("a" * min_length.to_i)).to be_empty
+      expect(validator.validate("a" * (min_length.to_i + 1))).to be_empty
+    end
+
+    it "accepts values with length less than or equal to a specified max_length" do
+      validator = described_class.new(max_length: max_length, required: true)
+
+      expect(validator.validate("a" * max_length.to_i)).to be_empty
+      expect(validator.validate("a" * (max_length.to_i - 1))).to be_empty
+    end
+
+    it "accepts values with length within the range indicated by both min_length and max_length" do
+      validator = described_class.new(min_length: min_length, max_length: max_length, required: true)
+
+      expect(validator.validate("a" * min_length.to_i)).to be_empty
+      expect(validator.validate("a" * max_length.to_i)).to be_empty
+      expect(validator.validate("a" * ((min_length.to_i + max_length.to_i) / 2))).to be_empty
+    end
+
+    it "rejects values with length less than the specified min_length" do
+      validator = described_class.new(min_length: min_length, required: true)
+
+      expect(validator.validate("a" * (min_length.to_i - 1))).not_to be_empty
+    end
+
+    it "rejects values with length greater than the specified max_length" do
+      validator = described_class.new(max_length: max_length, required: true)
+
+      expect(validator.validate("a" * (max_length.to_i + 1))).not_to be_empty
+    end
+
+    it "rejects values with length outside the range indicated by both min_length and max_length" do
+      validator = described_class.new(min_length: min_length, max_length: max_length, required: true)
+
+      expect(validator.validate("a" * (min_length.to_i - 1))).not_to be_empty
+      expect(validator.validate("a" * (max_length.to_i + 1))).not_to be_empty
+    end
+  end
+
+  context "with pattern" do
+    subject(:validator) { described_class.new(pattern: pattern, required: true) }
+
+    let(:pattern) { /\A[a-z]+\z/ }
+
+    it "accepts values that match the pattern" do
+      expect(validator.validate("abc")).to be_empty
+    end
+
+    it "rejects values that do not match the pattern" do
+      expect(validator.validate("123")).not_to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe SBOM::CycloneDX::Validator::UnionValidator do
+  describe "#initialize" do
+    it "requires :of" do
+      expect { described_class.new(of: %i[integer 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
+
+  context "when :of contains symbols" do
+    let(:of) { %i[integer string] }
+    let(:value) { [Faker::Number.number, Faker::Lorem.word].sample }
+
+    describe "#initialize" do
+      it "accepts symbols representing simple types" do
+        expect { described_class.new(of: of) }.not_to raise_error
+      end
+    end
+
+    describe "#validate" do
+      subject(:instance) { described_class.new(of: of) }
+
+      it "returns an empty array when value is one of the specified types" do
+        expect(instance.validate(value)).to be_empty
+      end
+
+      it "returns an array of error messages when value is not one of the specified types" do
+        expect(instance.validate(true)).not_to be_empty
+      end
+    end
+  end
+
+  context "when :of contains arrays" do
+    let(:of) { [[:integer, minimum: 0, maximum: 10], [:string, min_length: 1, max_length: 2]] }
+    let(:value) { [Faker::Number.within(range: 0..10), Faker::Lorem.characters(number: 1..2)].sample }
+
+    describe "#initialize" do
+      it "accepts an array representing validator creation arguments" do
+        expect { described_class.new(of: of) }.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(of: [:boolean, %i[string integer]]) }.to raise_error(Exception)
+      end
+    end
+
+    describe "#validate" do
+      subject(:instance) { described_class.new(of: of) }
+
+      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("dddd")).not_to be_empty
+        expect(instance.validate(11)).not_to be_empty
+      end
+    end
+  end
+end

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

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

data/spec/sbom/cyclone_dx/validator_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "active_support/all"
+require "sbom/cyclone_dx"
+require "sbom/cyclone_dx/record"
+require "sbom/cyclone_dx/validator"
+
+describe SBOM::CycloneDX::Validator do
+  describe "#for" do
+    let(:type_args) do
+      {
+        SBOM::CycloneDX::Validator::ArrayValidator => [:array, items: :boolean],
+        SBOM::CycloneDX::Validator::BooleanValidator => [:boolean, {}],
+        SBOM::CycloneDX::Validator::DateTimeValidator => [:date_time, {}],
+        SBOM::CycloneDX::Validator::EmailAddressValidator => [:email_address, {}],
+        SBOM::CycloneDX::Validator::FloatValidator => [:float, {}],
+        SBOM::CycloneDX::Validator::IntegerValidator => [:integer, {}],
+        SBOM::CycloneDX::Validator::RecordValidator => [Class.new(SBOM::CycloneDX::Record::Base), {}],
+        SBOM::CycloneDX::Validator::StringValidator => [:string, {}],
+        SBOM::CycloneDX::Validator::UnionValidator => [:union, of: %i[string integer]],
+        SBOM::CycloneDX::Validator::URIValidator => [:uri, {}]
+      }
+    end
+
+    it "returns the correct validator instance for the given type" do
+      type_args.each do |validator_class, (type, type_args)|
+        validator = described_class.for(type, **type_args)
+        expect(validator).to be_a(validator_class)
+      end
+    end
+
+    it "raises an ArgumentError when an unsupported type is given", rbs_test: :skip do
+      expect { described_class.for(:unsupported) }.to raise_error(ArgumentError, "Unsupported type: unsupported")
+      expect { described_class.for(Set) }.to raise_error(ArgumentError, "Unsupported type: Set")
+    end
+  end
+end

data/spec/sbom/cyclone_dx/version_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe SBOM::CycloneDX do # rubocop:disable RSpec/SpecFilePathFormat
+  it "has a version number" do
+    expect(described_class::VERSION).not_to be_nil
+  end
+end

data/spec/sbom/cyclone_dx_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe SBOM::CycloneDX do
+  it "has a version number" do
+    expect(SBOM::CycloneDX::VERSION).not_to be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "sbom/cyclone_dx"
+require "factory_bot"
+require "faker"
+require "rspec"
+
+RSpec.configure do |config|
+  config.include FactoryBot::Syntax::Methods
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.example_status_persistence_file_path = ".rspec_state"
+  config.disable_monkey_patching!
+  config.expose_dsl_globally = true
+
+  if config.files_to_run.one?
+    config.default_formatter = "doc"
+    config.warnings = true
+  else
+    config.profile_examples = 10
+  end
+
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.before(:suite) do
+    FactoryBot.find_definitions
+  end
+end