lapis-minecraft-versioning 0.5.0

data/spec/factories/manifest_document_factory.rb

@@ -0,0 +1,48 @@
+require 'json'
+
+FactoryGirl.define do
+  factory :manifest_document_entry, class: Array do
+    transient do
+      version { build(:basic) }
+    end
+
+    initialize_with do
+      {
+          :id          => version.id,
+          :time        => version.time.json_time,
+          :releaseTime => version.time.json_time,
+          :url         => version.url,
+          :type        => case version.type
+                            when :alpha
+                              'old_alpha'
+                            when :beta
+                              'old_beta'
+                            else
+                              version.type.to_s
+                          end
+      }
+    end
+  end
+
+  ManifestStruct = Struct.new(:source, :document)
+
+  factory :manifest_document, class: ManifestStruct do
+    transient do
+      source { build(:manifest) }
+      structure do
+        {
+            :latest => {
+                :release  => source.latest_release.id,
+                :snapshot => source.latest_snapshot.id
+            },
+            :versions => source.map do |version|
+              build(:manifest_document_entry, :version => version)
+            end
+        }
+      end
+      json { structure.to_json }
+    end
+
+    initialize_with { new(source, json) }
+  end
+end

data/spec/factories/manifest_factory.rb

@@ -0,0 +1,12 @@
+FactoryGirl.define do
+  factory :manifest, class: Lapis::Minecraft::Versioning::Manifest do
+    transient do
+      version_count 5
+      versions { build_list(:basic, version_count) }
+      latest_release_id { versions.first.id }
+      latest_snapshot_id { versions.last.id }
+    end
+
+    initialize_with { new(versions, latest_release_id, latest_snapshot_id) }
+  end
+end

data/spec/factories/meta_server_mock_factory.rb

@@ -0,0 +1,33 @@
+# FIXME: Implement proper mocking.
+class MetaServerMock
+  def initialize(manifest, details, assets)
+    @manifest = manifest
+    @details  = details
+    @assets   = assets.freeze
+  end
+
+  def get_manifest(_)
+    @manifest
+  end
+
+  def get_details(_)
+    @details
+  end
+
+  def get_assets(_)
+    @assets
+  end
+end
+
+FactoryGirl.define do
+  factory :meta_server_mock, :class => MetaServerMock do
+    transient do
+      assets { build_list(:asset, 20) }
+      asset_index { build(:asset_index, :assets => assets) }
+      detailed { build(:detailed, :asset_index => asset_index) }
+      manifest { build(:manifest) }
+    end
+
+    initialize_with { new(manifest, detailed, assets) }
+  end
+end

data/spec/factories/os_rule_factory.rb

@@ -0,0 +1,30 @@
+FactoryGirl.define do
+  factory :os_rule, parent: :rule, class: Lapis::Minecraft::Versioning::OSRule do
+    transient do
+      os_type :osx
+      os_version '^10\\.5\\.\\d$'
+    end
+
+    trait :windows do
+      os_type :windows
+    end
+
+    trait :linux do
+      os_type :linux
+    end
+
+    trait :osx do
+      os_type :osx
+    end
+
+    trait :has_version do
+      os_version '^10\\.5\\.\\d$'
+    end
+
+    trait :no_version do
+      os_version nil
+    end
+
+    initialize_with { new(is_allowed, os_type, os_version) }
+  end
+end

data/spec/factories/resource_factory.rb

@@ -0,0 +1,32 @@
+FactoryGirl.define do
+  factory :resource, parent: :asset, aliases: [:download], class: Lapis::Minecraft::Versioning::Resource do
+    transient do
+      sequence(:url) { |n| "http://example.com/minecraft/resources/#{n}.png" }
+      classifier 'artifact'
+    end
+
+    trait :client do
+      classifier 'client'
+      path nil
+    end
+
+    trait :server do
+      classifier 'server'
+      path nil
+    end
+
+    trait :windows do
+      classifier 'natives-windows'
+    end
+
+    trait :linux do
+      classifier 'natives-linux'
+    end
+
+    trait :osx do
+      classifier 'natives-osx'
+    end
+
+    initialize_with { new(url, size, sha1, path, classifier) }
+  end
+end

data/spec/factories/resource_set_factory.rb

@@ -0,0 +1,16 @@
+FactoryGirl.define do
+  factory :resource_set, class: Lapis::Minecraft::Versioning::ResourceSet do
+    transient do
+      windows { build(:resource, :windows) }
+      linux { build(:resource, :linux) }
+      osx { build(:resource, :osx) }
+      artifact { build(:resource) }
+      windows_classifier { windows.classifier }
+      linux_classifier { linux.classifier }
+      osx_classifier { osx.classifier }
+      resources { [artifact, windows, linux, osx] }
+    end
+
+    initialize_with { new(resources, windows_classifier, linux_classifier, osx_classifier) }
+  end
+end

data/spec/factories/rule_factory.rb

@@ -0,0 +1,17 @@
+FactoryGirl.define do
+  factory :rule, class: Lapis::Minecraft::Versioning::Rule do
+    transient do
+      is_allowed true
+    end
+
+    trait :allow do
+      is_allowed true
+    end
+
+    trait :disallow do
+      is_allowed false
+    end
+
+    initialize_with { new(is_allowed) }
+  end
+end

data/spec/factories/version_document_factory.rb

@@ -0,0 +1,176 @@
+require 'json'
+
+FactoryGirl.define do
+  factory :asset_index_document_entry, class: Hash do
+    transient do
+      source { build(:detailed) }
+    end
+
+    initialize_with do
+      {
+          :id        => source.asset_index.id,
+          :sha1      => source.asset_index.sha1,
+          :size      => source.asset_index.size,
+          :url       => source.asset_index.url,
+          :totalSize => source.asset_index.total_size
+      }
+    end
+  end
+
+  factory :download_document_entry, class: Array do
+    transient do
+      download { build(:download) }
+    end
+
+    initialize_with do
+      hash = {
+          :sha1 => download.sha1,
+          :size => download.size,
+          :url  => download.url
+      }
+      hash[:path] = download.path if download.path
+      [download.classifier, hash]
+    end
+  end
+
+  factory :downloads_document_entry, class: Hash do
+    transient do
+      downloads { build_list(:download, 3) }
+    end
+
+    initialize_with do
+      Hash[downloads.map { |download| build(:download_document_entry, :download => download) }]
+    end
+  end
+
+  factory :resources_document_entry, class: Hash do
+    transient do
+      resources { build(:resource_set) }
+    end
+
+    initialize_with do
+      hash = {
+          :classifiers => Hash[resources.resources.reject do |resource|
+            resource.classifier == 'artifact'
+          end.map do |resource|
+            build(:download_document_entry, :download => resource)
+          end]
+      }
+      hash.delete(:classifiers) if hash[:classifiers].empty?
+      if (artifact = resources.resources.find { |resource| resource.classifier == 'artifact' })
+        hash[:artifact] = {
+            :sha1 => artifact.sha1,
+            :size => artifact.size,
+            :url  => artifact.url
+        }
+        hash[:artifact][:path] = artifact.path if artifact.path
+      end
+      hash
+    end
+  end
+
+  factory :rule_document_entry, class: Hash do
+    transient do
+      rule { build(:rule) }
+    end
+
+    initialize_with do
+      hash = {
+          :action => rule.allowed? ? 'allow' : 'disallow'
+      }
+      if rule.is_a? Lapis::Minecraft::Versioning::OSRule
+        hash[:os] = { :name => rule.os_type }
+        version_regex = rule.os_version.source
+        unless version_regex.empty?
+          hash[:os][:version] = version_regex
+        end
+      end
+      hash
+    end
+  end
+
+  factory :rules_document_entry, class: Array do
+    transient do
+      rules { build_list(:rule, 2) }
+    end
+
+    initialize_with do
+      rules.map { |rule| build(:rule_document_entry, :rule => rule) }
+    end
+  end
+
+  factory :library_document_entry, class: Hash do
+    transient do
+      library { build(:library) }
+    end
+
+    initialize_with do
+      hash = {
+          :name      => library.name,
+          :downloads => build(:resources_document_entry, :resources => library.resources)
+      }
+      if library.resources.windows_classifier || library.resources.linux_classifier || library.resources.osx_classifer
+        hash[:natives] = {}
+        if library.resources.windows_classifier
+          hash[:natives][:windows] = library.resources.windows_classifier
+        end
+        if library.resources.linux_classifier
+          hash[:natives][:linux] = library.resources.linux_classifier
+        end
+        if library.resources.osx_classifier
+          hash[:natives][:osx] = library.resources.osx_classifier
+        end
+      end
+      if library.rules.any?
+        hash[:rules] = build(:rules_document_entry, :rules => library.rules)
+      end
+      if library.exclude_paths.any?
+        hash[:extract] = { :exclude => library.exclude_paths }
+      end
+      hash
+    end
+  end
+
+  factory :libraries_document_entry, class: Array do
+    transient do
+      source { build(:detailed) }
+    end
+
+    initialize_with do
+      source.libraries.map { |library| build(:library_document_entry, :library => library) }
+    end
+  end
+
+  VersionStruct = Struct.new(:source, :document)
+
+  factory :version_document, class: VersionStruct do
+    transient do
+      source { build(:detailed) }
+      structure do
+        {
+            :assetIndex             => build(:asset_index_document_entry, :source => source),
+            :assets                 => source.asset_index.id,
+            :downloads              => build(:downloads_document_entry, :downloads => source.downloads),
+            :id                     => source.id,
+            :libraries              => build(:libraries_document_entry, :source => source),
+            :mainClass              => source.launcher_properties.main_class,
+            :minecraftArguments     => source.launcher_properties.arguments.join(' '),
+            :minimumLauncherVersion => source.launcher_properties.minimum_version,
+            :releaseTime            => source.time.json_time,
+            :time                   => source.time.json_time,
+            :type                   => case source.type
+                                         when :alpha
+                                           'old_alpha'
+                                         when :beta
+                                           'old_beta'
+                                         else
+                                           source.type.to_s
+                                       end
+        }
+      end
+      json { structure.to_json }
+    end
+
+    initialize_with { new(source, json) }
+  end
+end

data/spec/factories/version_factory.rb

@@ -0,0 +1,18 @@
+FactoryGirl.define do
+  factory :version, parent: :basic, class: Lapis::Minecraft::Version do
+    transient do
+      assets { build_list(:asset, 20) }
+      asset_index { build(:asset_index, :assets => assets) }
+      downloads { [build(:download, :client), build(:download, :server), build(:resource)] }
+      libraries { build_list(:library, 5) }
+      launcher_properties { build(:launcher) }
+      detailed { build(:detailed, :assets => assets, :asset_index => asset_index, :downloads => downloads, :libraries => libraries, :launcher_properties => launcher_properties) }
+      meta_server { build(:meta_server_mock, :assets => assets, :detailed => detailed) }
+    end
+
+    initialize_with do
+      basic = Lapis::Minecraft::Versioning::Basic.new(id, type, time, url)
+      new(basic, meta_server)
+    end
+  end
+end

data/spec/lapis/minecraft/version_spec.rb

@@ -0,0 +1,181 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Lapis::Minecraft::Version do
+
+  describe '#id' do
+    let(:id) { 'beta1.8' }
+    let(:version) { build(:version, :id => id) }
+    subject { version.id }
+
+    it 'is the expected value' do
+      is_expected.to eq id
+    end
+
+    it 'is frozen' do
+      is_expected.to be_frozen
+    end
+  end
+
+  describe '#type' do
+    let(:type) { :beta }
+    let(:version) { build(:version, :type => type) }
+    subject { version.type }
+
+    it 'is the expected value' do
+      is_expected.to eq type
+    end
+  end
+
+  describe '#time' do
+    let(:time) { 3.years.ago }
+    let(:version) { build(:version, :time => time) }
+    subject { version.time }
+
+    it 'is the expected value' do
+      is_expected.to eq time
+    end
+  end
+
+  describe '#url' do
+    let(:url) { 'https://example.com/minecraft/versions/beta1.8.json' }
+    let(:version) { build(:version, :url => url) }
+    subject { version.url }
+
+    it 'is the expected value' do
+      is_expected.to eq url
+    end
+
+    it 'is frozen' do
+      is_expected.to be_frozen
+    end
+  end
+
+  describe '#asset_index' do
+    let(:asset_index) { build(:asset_index) }
+    let(:version) { build(:version, :asset_index => asset_index) }
+    subject { version.asset_index }
+
+    it 'retrieves the expected value' do
+      is_expected.to eq asset_index
+    end
+  end
+
+  describe '#assets' do
+    let(:assets) { build_list(:asset, 5) }
+    let(:version) { build(:version, :assets => assets) }
+    subject { version.assets }
+
+    it 'retrieves the expected items' do
+      is_expected.to contain_exactly(*assets)
+    end
+
+    it 'is frozen' do
+      is_expected.to be_frozen
+    end
+  end
+
+  describe '#downloads' do
+    let(:downloads) { build_list(:download, 5) }
+    let(:version) { build(:version, :downloads => downloads) }
+    subject { version.downloads }
+
+    it 'retrieves the expected items' do
+      is_expected.to contain_exactly(*downloads)
+    end
+
+    it 'is frozen' do
+      is_expected.to be_frozen
+    end
+  end
+
+  describe '#client_download' do
+    let(:version) { build(:version, :downloads => downloads) }
+    subject { version.client_download }
+
+    context 'with a client provided' do
+      let(:client) { build(:download, :client) }
+      let(:downloads) { build_list(:download, 3) << client }
+
+      it 'finds the client' do
+        is_expected.to be client
+      end
+    end
+
+    context 'without a client provided' do
+      let(:downloads) { build_list(:download, 3) }
+
+      it 'returns nil' do
+        is_expected.to eq nil
+      end
+    end
+  end
+
+  describe '#server_download' do
+    let(:version) { build(:version, :downloads => downloads) }
+    subject { version.server_download }
+
+    context 'with a server provided' do
+      let(:server) { build(:download, :server) }
+      let(:downloads) { build_list(:download, 3) << server }
+
+      it 'finds the server' do
+        is_expected.to be server
+      end
+    end
+
+    context 'without a server provided' do
+      let(:downloads) { build_list(:download, 3) }
+
+      it 'returns nil' do
+        is_expected.to eq nil
+      end
+    end
+  end
+
+  describe '#libraries' do
+    let(:libraries) { build_list(:library, 5) }
+    let(:version) { build(:version, :libraries => libraries) }
+    subject { version.libraries }
+
+    it 'retrieves the expected items' do
+      is_expected.to contain_exactly(*libraries)
+    end
+
+    it 'is frozen' do
+      is_expected.to be_frozen
+    end
+  end
+
+  describe '#launcher_properties' do
+    let(:launcher) { build(:launcher) }
+    let(:version) { build(:version, :launcher_properties => launcher) }
+    subject { version.launcher_properties }
+
+    it 'retrieves the expected value' do
+      is_expected.to eq launcher
+    end
+  end
+
+  describe '#==' do
+    subject { version_1 == version_2 }
+
+    context 'with identical versions' do
+      let(:version_1) { build(:version) }
+      let(:version_2) { version_1.dup } # Too difficult to make a proper copy.
+
+      it 'is true' do
+        is_expected.to be true
+      end
+    end
+
+    context 'with different versions' do
+      let(:version_1) { build(:version) }
+      let(:version_2) { build(:version, :id => version_1.id + '-foobar') }
+
+      it 'is false' do
+        is_expected.to be false
+      end
+    end
+  end
+
+end