metasploit-model 0.24.1.pre.semantic.pre.versioning.pre.2.pre.0

data/spec/dummy/spec/factories/dummy/module/ranks.rb

@@ -0,0 +1,14 @@
+FactoryGirl.define do
+  # Dummy::Module::Rank does not have a factory because all valid records are seeded, so it only has a sequence to grab
+  # a seeded record
+
+  names = Metasploit::Model::Module::Rank::NUMBER_BY_NAME.keys
+
+  sequence :dummy_module_rank do |n|
+    name = names[n % names.length]
+
+    rank = Dummy::Module::Rank.with_name(name)
+
+    rank
+  end
+end

data/spec/dummy/spec/factories/dummy/module/references.rb

@@ -0,0 +1,17 @@
+FactoryGirl.define do
+  factory :dummy_module_reference,
+          class: Dummy::Module::Reference,
+          traits: [
+              :metasploit_model_base,
+              :metasploit_model_module_reference
+          ] do
+    ignore do
+      # have to use module_type from metasploit_model_module_reference trait to ensure module_instance will support
+      # module references.
+      module_class { FactoryGirl.create(:dummy_module_class, module_type: module_type) }
+    end
+
+    module_instance { FactoryGirl.create(:dummy_module_instance, module_class: module_class) }
+    association :reference, factory: :dummy_reference
+  end
+end

data/spec/dummy/spec/factories/dummy/module/target/architectures.rb

@@ -0,0 +1,40 @@
+FactoryGirl.define do
+  factory :dummy_module_target_architecture,
+          class: Dummy::Module::Target::Architecture,
+          traits: [
+              :metasploit_model_base
+          ] do
+    architecture { generate :dummy_architecture }
+    association :module_target,
+                factory: :dummy_module_target,
+                strategy: :build,
+                # disable module_target factory from building target_architectures since this factory is already
+                # building one
+                target_architectures_length: 0
+
+    after(:build) do |module_target_architecture|
+      module_target = module_target_architecture.module_target
+
+      if module_target
+        unless module_target.target_architectures.include? module_target_architecture
+          module_target.target_architectures << module_target_architecture
+        end
+
+        architecture = module_target_architecture.architecture
+        module_instance = module_target.module_instance
+
+        if architecture && module_instance
+          actual_architecture_set = module_instance.module_architectures.map(&:architecture)
+
+          unless actual_architecture_set.include? architecture
+            module_instance.module_architectures << FactoryGirl.build(
+                :dummy_module_architecture,
+                architecture: architecture,
+                module_instance: module_instance
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/spec/dummy/spec/factories/dummy/module/target/platforms.rb

@@ -0,0 +1,41 @@
+FactoryGirl.define do
+  factory :dummy_module_target_platform,
+          class: Dummy::Module::Target::Platform,
+          traits: [
+              :metasploit_model_base
+          ] do
+    association :module_target,
+                factory: :dummy_module_target,
+                strategy: :build,
+                # disable module_target factory from building target_platforms since this factory is already
+                # building one
+                target_platforms_length: 0
+
+    platform { generate :dummy_platform }
+
+    after(:build) do |module_target_platform|
+      module_target = module_target_platform.module_target
+
+      if module_target
+        unless module_target.target_platforms.include? module_target_platform
+          module_target.target_platforms << module_target_platform
+        end
+
+        module_instance = module_target.module_instance
+        platform = module_target_platform.platform
+
+        if module_instance && platform
+          actual_platform_set = module_instance.module_platforms.map(&:platform)
+
+          unless actual_platform_set.include? platform
+            module_instance.module_platforms << FactoryGirl.build(
+                :dummy_module_platform,
+                module_instance: module_instance,
+                platform: platform
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/spec/dummy/spec/factories/dummy/module/targets.rb

@@ -0,0 +1,46 @@
+FactoryGirl.define do
+  factory :dummy_module_target,
+          :class => Dummy::Module::Target,
+          :traits => [
+              :metasploit_model_base,
+              :metasploit_model_module_target
+          ] do
+    ignore do
+      # have to use module_type from metasploit_model_module_target trait to ensure module_instance will support
+      # module targets.
+      module_class { FactoryGirl.create(:dummy_module_class, module_type: module_type) }
+    end
+
+    module_instance {
+      # module_instance MUST be built because it will fail validation without targets
+      FactoryGirl.build(
+          :dummy_module_instance,
+          module_class: module_class,
+          # disable module_instance factory's after(:build) from building module_targets since this factory is already
+          # building it and if they both build module_targets, then the validations will detect a mismatch.
+          targets_length: 0
+      )
+    }
+
+    after(:build) { |dummy_module_target, evaluator|
+      [:architecture, :platform].each do |infix|
+        attribute = "target_#{infix.to_s.pluralize}"
+        factory = "dummy_module_target_#{infix}"
+        length = evaluator.send("#{attribute}_length")
+
+        # factories add selves to associations on dummy_module_target
+        FactoryGirl.build_list(
+            factory,
+            length,
+            module_target: dummy_module_target
+        )
+      end
+
+      module_instance = dummy_module_target.module_instance
+
+      unless module_instance.targets.include? dummy_module_target
+        module_instance.targets << dummy_module_target
+      end
+    }
+  end
+end

data/spec/dummy/spec/factories/dummy/platforms.rb

@@ -0,0 +1,3 @@
+FactoryGirl.define do
+  sequence :dummy_platform, Dummy::Platform.all.cycle
+end

data/spec/dummy/spec/factories/dummy/references.rb

@@ -0,0 +1,26 @@
+FactoryGirl.define do
+  factory :dummy_reference,
+          :class => Dummy::Reference,
+          :traits => [
+              :metasploit_model_base,
+              :metasploit_model_reference
+          ] do
+    #
+    # Associations
+    #
+
+    association :authority, :factory => :dummy_authority
+
+    factory :obsolete_dummy_reference,
+            :traits => [
+                :obsolete_metasploit_model_reference
+            ] do
+      association :authority, :factory => :obsolete_dummy_authority
+    end
+
+    factory :url_dummy_reference,
+            :traits => [
+                :url_metasploit_model_reference
+            ]
+  end
+end

data/spec/factories/metasploit/model/architectures.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  sequence :metasploit_model_architecture_abbreviation, Metasploit::Model::Architecture::ABBREVIATIONS.cycle
+  sequence :metasploit_model_architecture_bits, Metasploit::Model::Architecture::BITS.cycle
+  sequence :metasploit_model_architecture_endianness, Metasploit::Model::Architecture::ENDIANNESSES.cycle
+  sequence :metasploit_model_architecture_family, Metasploit::Model::Architecture::FAMILIES.cycle
+end

data/spec/factories/metasploit/model/association/reflections.rb

@@ -0,0 +1,9 @@
+FactoryGirl.define do
+  sequence :metasploit_model_association_reflection_class_name do |n|
+    "Metasploit::Model::Association::Reflection::Class#{n}"
+  end
+
+  sequence :metasploit_model_association_reflection_name do |n|
+    "metasploit_model_association_reflection_name#{n}".to_sym
+  end
+end

data/spec/factories/metasploit/model/authorities.rb

@@ -0,0 +1,28 @@
+FactoryGirl.define do
+  sequence :metasploit_model_authority_abbreviation do |n|
+    # can't use '-' as {Metasploit::Model::Search::Operator::Deprecated::Ref} treats '-' as separating authority
+    # abbreviation from reference designation.
+    "METASPLOIT_MODEL_AUTHORITY#{n}"
+  end
+
+  sequence :metasploit_model_authority_summary do |n|
+    "Metasploit::Model::Authority #{n}"
+  end
+
+  sequence :metasploit_model_authority_url do |n|
+    "http://example.com/metasploit/model/authority/#{n}"
+  end
+
+  trait :metasploit_model_authority do
+    abbreviation { generate :metasploit_model_authority_abbreviation }
+  end
+
+  trait :full_metasploit_model_authority do
+    summary { generate :metasploit_model_authority_summary }
+    url { generate :metasploit_model_authority_url }
+  end
+
+  trait :obsolete_metasploit_model_authority do
+    obsolete { true }
+  end
+end

data/spec/factories/metasploit/model/authors.rb

@@ -0,0 +1,9 @@
+FactoryGirl.define do
+  sequence :metasploit_model_author_name do |n|
+    "Metasploit::Model::Author #{n}"
+  end
+
+  trait :metasploit_model_author do
+    name { generate :metasploit_model_author_name }
+  end
+end

data/spec/factories/metasploit/model/bases.rb

@@ -0,0 +1,10 @@
+FactoryGirl.define do
+  trait :metasploit_model_base do
+    to_create do |instance|
+      # validate so before validation derivation occurs to mimic create for ActiveRecord.
+      unless instance.valid?
+        raise Metasploit::Model::Invalid.new(instance)
+      end
+    end
+  end
+end

data/spec/factories/metasploit/model/email_addresses.rb

@@ -0,0 +1,14 @@
+FactoryGirl.define do
+  sequence :metasploit_model_email_address_domain do |n|
+    "metasploit-model-email-address-domain#{n}.com"
+  end
+
+  sequence :metasploit_model_email_address_local do |n|
+    "metasploit.model.email.address.local+#{n}"
+  end
+
+  trait :metasploit_model_email_address do
+    domain { generate :metasploit_model_email_address_domain }
+    local { generate :metasploit_model_email_address_local }
+  end
+end

data/spec/factories/metasploit/model/module/actions.rb

@@ -0,0 +1,9 @@
+FactoryGirl.define do
+  sequence :metasploit_model_module_action_name do |n|
+    "Metasploit::Model::Module::Action#name #{n}"
+  end
+
+  trait :metasploit_model_module_action do
+    name { generate :metasploit_model_module_action_name }
+  end
+end

data/spec/factories/metasploit/model/module/ancestors.rb

@@ -0,0 +1,180 @@
+FactoryGirl.define do
+  sequence :metasploit_model_module_ancestor_handler_type do |n|
+    "metasploit_model_module_ancestor_handler_type#{n}"
+  end
+
+  minimum_version = 1
+  maximum_version = 4
+  range = maximum_version - minimum_version + 1
+
+  sequence :metasploit_model_module_ancestor_metasploit_module_relative_name do |n|
+    version = (n % range) + minimum_version
+
+    "Metasploit#{version}"
+  end
+
+  sequence :metasploit_model_module_ancestor_payload_type, Metasploit::Model::Module::Ancestor::PAYLOAD_TYPES.cycle
+
+  sequence :metasploit_model_module_ancestor_reference_name do |n|
+    [
+        'metasploit',
+        'model',
+        'module',
+        'ancestor',
+        'reference',
+        "name#{n}"
+    ].join('/')
+  end
+
+  sequence :metasploit_model_module_ancestor_non_payload_reference_name do |n|
+    [
+        'mdm',
+        'module',
+        'ancestor',
+        'non',
+        'payload',
+        'reference',
+        "name#{n}"
+    ].join('/')
+  end
+
+  payload_type_directories = Metasploit::Model::Module::Ancestor::PAYLOAD_TYPES.map(&:pluralize)
+
+  sequence :metasploit_model_module_ancestor_payload_reference_name do |n|
+    payload_type_directory = payload_type_directories[n % payload_type_directories.length]
+
+    [
+        payload_type_directory,
+        'metasploit',
+        'model',
+        'module',
+        'ancestor',
+        'payload',
+        'reference',
+        "name#{n}"
+    ].join('/')
+  end
+
+  sequence :metasploit_model_module_ancestor_relative_payload_name do |n|
+    [
+        'metasploit',
+        'model',
+        'module',
+        'ancestor',
+        'relative',
+        'payload',
+        "name#{n}"
+    ].join('/')
+  end
+
+  trait :metasploit_model_module_ancestor do
+    #
+    # Attributes
+    #
+
+    module_type { generate :metasploit_model_module_type }
+
+    ignore do
+      # depends on module_type
+      payload_type {
+        if payload?
+          generate :metasploit_model_module_ancestor_payload_type
+        else
+          nil
+        end
+      }
+
+      #
+      # Callback helpers
+      #
+
+      before_write_template {
+        ->(module_ancestor, evaluator){}
+      }
+      write_template {
+        ->(module_ancestor, evaluator){
+          Metasploit::Model::Module::Ancestor::Spec::Template.write(module_ancestor: module_ancestor)
+        }
+      }
+    end
+
+    # depends on module_type
+    reference_name {
+      if payload?
+        payload_type_directory = payload_type.pluralize
+        relative_payload_name = generate :metasploit_model_module_ancestor_relative_payload_name
+
+        [
+            payload_type_directory,
+            relative_payload_name
+        ].join('/')
+      else
+        generate :metasploit_model_module_ancestor_non_payload_reference_name
+      end
+    }
+
+    # depends on derived_payload_type which depends on reference_name
+    handler_type {
+      # can't use #handled? because it will check payload_type on model, not ignored field in factory, so use
+      # .handled?
+      if @instance.class.handled?(:module_type => module_type, :payload_type => derived_payload_type)
+        generate :metasploit_model_module_ancestor_handler_type
+      else
+        nil
+      end
+    }
+
+    #
+    # Callbacks
+    #
+
+    after(:build) do |module_ancestor, evaluator|
+      instance_exec(module_ancestor, evaluator, &evaluator.before_write_template)
+      instance_exec(module_ancestor, evaluator, &evaluator.write_template)
+    end
+  end
+
+  trait :non_payload_metasploit_model_module_ancestor do
+    module_type { generate :metasploit_model_non_payload_module_type }
+
+    ignore do
+      payload_type nil
+    end
+  end
+
+  trait :payload_metasploit_model_module_ancestor do
+    module_type 'payload'
+
+    ignore do
+      payload_type { generate :metasploit_model_module_ancestor_payload_type }
+    end
+
+    reference_name {
+      payload_type_directory = payload_type.pluralize
+      relative_payload_name = generate :metasploit_model_module_ancestor_relative_payload_name
+
+      [
+          payload_type_directory,
+          relative_payload_name
+      ].join('/')
+    }
+  end
+
+  trait :single_payload_metasploit_model_module_ancestor do
+    ignore do
+      payload_type 'single'
+    end
+  end
+
+  trait :stage_payload_metasploit_model_module_ancestor do
+    ignore do
+      payload_type 'stage'
+    end
+  end
+
+  trait :stager_payload_metasploit_model_module_ancestor do
+    ignore do
+      payload_type 'stager'
+    end
+  end
+end