lapis-minecraft-versioning 0.5.0

data/spec/lapis/minecraft/versioning/library_spec.rb

@@ -0,0 +1,91 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Lapis::Minecraft::Versioning::Library do
+
+  describe '#name' do
+    let(:name) { 'some.mc:library:5.0' }
+    let(:library) { build(:library, :name => name) }
+    subject { library.name }
+
+    it 'is the expected value' do
+      is_expected.to eq name
+    end
+
+    it 'is frozen' do
+      is_expected.to be_frozen
+    end
+  end
+
+  describe '#resources' do
+    let(:resources) { build(:resource_set) }
+    let(:library) { build(:library, :resources => resources) }
+    subject { library.resources }
+
+    it 'has the expected value' do
+      is_expected.to eq resources
+    end
+  end
+
+  describe '#rules' do
+    let(:rules) { build_list(:rule, 5) }
+    let(:library) { build(:library, :rules => rules) }
+    subject { library.rules }
+
+    it 'cloned the array' do
+      is_expected.not_to be rules
+    end
+
+    it 'has the same elements' do
+      is_expected.to contain_exactly(*rules)
+    end
+
+    it 'is frozen' do
+      is_expected.to be_frozen
+    end
+  end
+
+  describe '#exclude_paths' do
+    let(:paths) { build_list(:library_path, 5) }
+    let(:library) { build(:library, :paths => paths) }
+    subject { library.exclude_paths }
+
+    it 'cloned the array' do
+      is_expected.not_to be paths
+    end
+
+    it 'has the same elements' do
+      is_expected.to contain_exactly(*paths)
+    end
+
+    it 'is frozen' do
+      is_expected.to be_frozen
+    end
+
+    it 'has frozen contents' do
+      is_expected.to all(be_frozen)
+    end
+  end
+
+  describe '#==' do
+    subject { library_1 == library_2 }
+
+    context 'with identical libraries' do
+      let(:library_1) { build(:library) }
+      let(:library_2) { Lapis::Minecraft::Versioning::Library.new(library_1.name, library_1.resources, library_1.rules, library_1.exclude_paths) }
+
+      it 'is true' do
+        is_expected.to be true
+      end
+    end
+
+    context 'with different libraries' do
+      let(:library_1) { build(:library) }
+      let(:library_2) { build(:library, :name => library_1.name + '-foobar') }
+
+      it 'is false' do
+        is_expected.to be false
+      end
+    end
+  end
+
+end

data/spec/lapis/minecraft/versioning/manifest_spec.rb

@@ -0,0 +1,71 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Lapis::Minecraft::Versioning::Manifest do
+  let(:versions) { build_list(:basic, 5) }
+  let(:latest_release) { versions.first }
+  let(:latest_snapshot) { versions.last }
+  subject(:manifest) { build(:manifest, :versions => versions, :latest_release_id => latest_release.id, :latest_snapshot_id => latest_snapshot.id) }
+
+  describe '#each' do
+    subject { manifest.each }
+
+    it 'returns an enumerator' do
+      expect(subject).to be_an Enumerator
+    end
+
+    it 'yields basic info' do
+      args = []
+      manifest.each do |arg|
+        args << arg
+      end
+      expect(args).to all(be_a Lapis::Minecraft::Versioning::Basic)
+    end
+
+    it 'yields every version' do
+      expect { |b| manifest.each(&b) }.to yield_control.exactly(versions.count).times
+    end
+
+    it 'yields the expected versions' do
+      expect(manifest).to contain_exactly(*versions)
+    end
+  end
+
+  describe '#latest_release' do
+    subject { manifest.latest_release }
+
+    it 'is the expected value' do
+      is_expected.to be latest_release
+    end
+  end
+
+  describe '#latest_release' do
+    subject { manifest.latest_release }
+
+    it 'is the expected value' do
+      is_expected.to be latest_release
+    end
+  end
+
+  describe '#==' do
+    subject { manifest_1 == manifest_2 }
+
+    context 'with identical manifests' do
+      let(:manifest_1) { build(:manifest) }
+      let(:manifest_2) { Lapis::Minecraft::Versioning::Manifest.new(manifest_1.entries, manifest_1.latest_release.id, manifest_1.latest_snapshot.id) }
+
+      it 'is true' do
+        is_expected.to be true
+      end
+    end
+
+    context 'with different manifests' do
+      let(:manifest_1) { build(:manifest) }
+      let(:manifest_2) { build(:manifest, :versions => manifest_1.entries + [build(:basic)]) }
+
+      it 'is false' do
+        is_expected.to be false
+      end
+    end
+  end
+
+end

data/spec/lapis/minecraft/versioning/marshalling/asset_index_parser_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../../../../spec_helper'
+
+RSpec.describe Lapis::Minecraft::Versioning::Marshalling::AssetIndexParser do
+  let(:index) { build(:asset_index_document) }
+  let(:assets) { index.assets }
+  let(:document) { index.document }
+  subject(:parser) { Lapis::Minecraft::Versioning::Marshalling::AssetIndexParser.new }
+
+  describe '#parse' do
+    subject { parser.parse(document) }
+
+    it 'generates a list of assets' do
+      is_expected.to all(be_an Lapis::Minecraft::Versioning::Asset)
+    end
+
+    it 'has the expected assets' do
+      # FIXME: This test is longer and more complicated than I would like.
+      subject.zip(assets).each do |actual, expected|
+        path, attributes = expected
+        expect(actual.path).to eq path
+        expect(actual.sha1).to eq attributes[:hash]
+        expect(actual.size).to eq attributes[:size]
+      end
+    end
+  end
+
+end

data/spec/lapis/minecraft/versioning/marshalling/manifest_parser_spec.rb

@@ -0,0 +1,74 @@
+require_relative '../../../../spec_helper'
+
+RSpec.describe Lapis::Minecraft::Versioning::Marshalling::ManifestParser do
+  let(:manifest) { build(:manifest_document) }
+  let(:latest_release) { manifest.source.latest_release }
+  let(:latest_snapshot) { manifest.source.latest_snapshot }
+  let(:versions) { manifest.source.entries }
+  let(:document) { manifest.document }
+  subject(:parser) { Lapis::Minecraft::Versioning::Marshalling::ManifestParser.new }
+
+  describe '#parse' do
+    subject(:result) { parser.parse(document) }
+
+    it 'has the expected versions' do
+      is_expected.to contain_exactly(*versions)
+    end
+
+    describe '.latest_release' do
+      subject(:version) { result.latest_release }
+
+      it 'is the expected version' do
+        is_expected.to eq latest_release
+      end
+    end
+
+    describe '.latest_snapshot' do
+      subject(:version) { result.latest_snapshot }
+
+      it 'is the expected version' do
+        is_expected.to eq latest_snapshot
+      end
+    end
+
+    context 'when versions contain' do
+      let(:versions) { [version] }
+      let(:source) { build(:manifest, :versions => versions) }
+      let(:manifest) { build(:manifest_document, :source => source) }
+      subject { result.first.type }
+
+      context 'an alpha' do
+        let(:version) { build(:basic, :alpha) }
+
+        it 'sets the type to :alpha' do
+          is_expected.to eq :alpha
+        end
+      end
+
+      context 'a beta' do
+        let(:version) { build(:basic, :beta) }
+
+        it 'sets the type to :beta' do
+          is_expected.to eq :beta
+        end
+      end
+
+      context 'a snapshot' do
+        let(:version) { build(:basic, :snapshot) }
+
+        it 'sets the type to :snapshot' do
+          is_expected.to eq :snapshot
+        end
+      end
+
+      context 'a release' do
+        let(:version) { build(:basic, :release) }
+
+        it 'sets the type to :release' do
+          is_expected.to eq :release
+        end
+      end
+    end
+  end
+
+end

data/spec/lapis/minecraft/versioning/marshalling/version_parser_spec.rb

@@ -0,0 +1,101 @@
+require_relative '../../../../spec_helper'
+
+RSpec.describe Lapis::Minecraft::Versioning::Marshalling::VersionParser do
+  let(:source) { build(:detailed) }
+  let(:version) { build(:version_document, :source => source) }
+  let(:document) { version.document }
+  subject(:parser) { Lapis::Minecraft::Versioning::Marshalling::VersionParser.new }
+
+  describe '#parse' do
+    subject(:result) { parser.parse(document, "http://example.com/minecraft/#{source.id}.json") }
+
+    describe '.id' do
+      subject { result.id }
+
+      it 'is the expected value' do
+        is_expected.to eq source.id
+      end
+    end
+
+    describe '.type' do
+      subject { result.type }
+
+      context 'with an alpha' do
+        let(:source) { build(:detailed, :type => :alpha) }
+
+        it 'is :alpha' do
+          is_expected.to eq :alpha
+        end
+      end
+
+      context 'with a beta' do
+        let(:source) { build(:detailed, :type => :beta) }
+
+        it 'is :beta' do
+          is_expected.to eq :beta
+        end
+      end
+
+      context 'with a snapshot' do
+        let(:source) { build(:detailed, :type => :snapshot) }
+
+        it 'is :snapshot' do
+          is_expected.to eq :snapshot
+        end
+      end
+
+      context 'with a release' do
+        let(:source) { build(:detailed, :type => :release) }
+
+        it 'is :release' do
+          is_expected.to eq :release
+        end
+      end
+    end
+
+    describe '.time' do
+      subject { result.time }
+
+      it 'is the expected value' do
+        is_expected.to eq source.time
+      end
+    end
+
+    describe '.asset_index' do
+      subject(:index) { result.asset_index }
+
+      it 'has the expected values' do
+        is_expected.to eq source.asset_index
+      end
+    end
+
+    describe '.downloads' do
+      subject(:downloads) { result.downloads }
+
+      it 'has the expected contents' do
+        is_expected.to contain_exactly(*source.downloads)
+      end
+    end
+
+    describe '.libraries' do
+      let(:rule) { build(:rule) }
+      let(:os_rule) { build(:os_rule) }
+      let(:source_libraries) { build_list(:library, 5, :rules => [rule, os_rule]) }
+      let(:source) { build(:detailed, :libraries => source_libraries) }
+      subject(:libraries) { result.libraries }
+
+      it 'has the expected contents' do
+        is_expected.to contain_exactly(*source.libraries)
+      end
+    end
+
+    describe '.launcher_properties' do
+      subject(:launcher) { result.launcher_properties }
+
+      it 'has the expected values' do
+        is_expected.to eq source.launcher_properties
+      end
+    end
+  end
+
+end

data/spec/lapis/minecraft/versioning/meta_server_spec.rb

@@ -0,0 +1,59 @@
+require 'httpclient'
+
+RSpec.describe Lapis::Minecraft::Versioning::MetaServer do
+  let(:manifest) { build(:manifest) }
+  let(:detailed) { build(:detailed) }
+  let(:assets) { build_list(:asset, 5) }
+  let(:manifest_document) { build(:manifest_document, :source => manifest) }
+  let(:version_document) { build(:version_document, :source => detailed) }
+  let(:asset_index_document) { build(:asset_index_document, :assets => assets) }
+  let(:manifest_url) { 'http://example.com/minecraft/version_manifest.json' }
+  let(:version_url) { 'http://example.com/minecraft/versions/1.0.json' }
+  let(:assets_url) { 'http://example.com/minecraft/assets/1.0.json' }
+  let(:client) { double('HTTPClient') }
+  subject(:meta_server) { Lapis::Minecraft::Versioning::MetaServer.new(client) }
+  before do
+    allow(client).to receive(:get) do |url, *_|
+      case url
+        when manifest_url
+          HTTP::Message.new_response(manifest_document.document)
+        when version_url
+          HTTP::Message.new_response(version_document.document)
+        when assets_url
+          HTTP::Message.new_response(asset_index_document.document)
+        else
+          HTTP::Message.new_response(nil).tap do |response|
+            response.status = 404
+          end
+      end
+    end
+  end
+
+  describe '#get_manifest' do
+    subject(:result) { meta_server.get_manifest(manifest_url) }
+    before { expect(client).to receive(:get).with(manifest_url) }
+
+    it 'returns a Manifest instance' do
+      is_expected.to be_a Lapis::Minecraft::Versioning::Manifest
+    end
+  end
+
+  describe '#get_version' do
+    subject(:result) { meta_server.get_details(version_url) }
+    before { expect(client).to receive(:get).with(version_url) }
+
+    it 'returns a Detailed instance' do
+      is_expected.to be_a Lapis::Minecraft::Versioning::Detailed
+    end
+  end
+
+  describe '#get_assets' do
+    subject(:result) { meta_server.get_assets(assets_url) }
+    before { expect(client).to receive(:get).with(assets_url) }
+
+    it 'returns a list of assets' do
+      is_expected.to all(be_an Lapis::Minecraft::Versioning::Asset)
+    end
+  end
+
+end

data/spec/lapis/minecraft/versioning/os_rule_spec.rb

@@ -0,0 +1,73 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Lapis::Minecraft::Versioning::OSRule do
+
+  describe '#allowed?' do
+    let(:rule) { build(:os_rule, :allow) }
+    subject { rule.allowed? }
+
+    it 'is the expected value' do
+      is_expected.to be_truthy
+    end
+  end
+
+  describe '#os_type' do
+    let(:rule) { build(:os_rule, :linux) }
+    subject { rule.os_type }
+
+    it 'is the expected value' do
+      is_expected.to eq :linux
+    end
+  end
+
+  describe '#os_version' do
+    subject { rule.os_version }
+
+    context 'with version specified' do
+      let(:rule) { build(:os_rule, :os_version => '^5\\.0$') }
+
+      it 'is a Regexp' do
+        is_expected.to be_a Regexp
+      end
+
+      it 'is the expected regular expression' do
+        expect(subject.match '5.0')
+      end
+    end
+
+    context 'without version specified' do
+      let(:rule) { build(:os_rule, :no_version) }
+
+      it 'is a Regexp' do
+        is_expected.to be_a Regexp
+      end
+
+      it 'matches any version' do
+        expect(subject.match '5.0')
+      end
+    end
+  end
+
+  describe '#==' do
+    subject { rule_1 == rule_2 }
+
+    context 'with identical rules' do
+      let(:rule_1) { build(:os_rule) }
+      let(:rule_2) { Lapis::Minecraft::Versioning::OSRule.new(rule_1.allowed?, rule_1.os_type, rule_1.os_version.source) }
+
+      it 'is true' do
+        is_expected.to be true
+      end
+    end
+
+    context 'with different rules' do
+      let(:rule_1) { build(:os_rule) }
+      let(:rule_2) { build(:os_rule, :os_version => rule_1.os_version.source + '-foobar') }
+
+      it 'is false' do
+        is_expected.to be false
+      end
+    end
+  end
+
+end