audiothority 0.1.0

data/spec/audiothority/society_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Audiothority
+  describe Society do
+    let :society do
+      described_class.new(location, fileutils)
+    end
+
+    let :location do
+      'society'
+    end
+
+    let :fileutils do
+      double(:fileutils, move: 0)
+    end
+
+    describe '#transfer' do
+      it 'moves the enforced entity to society location' do
+        society.transfer('enforced')
+        expect(fileutils).to have_received(:move).with('enforced', Pathname.new('society'))
+      end
+    end
+  end
+end

data/spec/audiothority/tracker_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Audiothority
+  describe Tracker do
+    let :tracker do
+      described_class.new
+    end
+
+    let :violations do
+      [double(:violation)]
+    end
+
+    describe '#mark' do
+      it 'adds path and violations' do
+        tracker.mark('path', violations)
+        expect(tracker.suspects).to eq({'path' => violations})
+      end
+    end
+
+    describe '#suspects' do
+      it 'returns marked paths with violations' do
+        tracker.mark('path', violations)
+        expect(tracker.suspects).to eq({'path' => violations})
+      end
+
+      it 'freezes the returned suspects' do
+        expect(tracker.suspects).to be_frozen
+      end
+    end
+  end
+end

data/spec/audiothority/validators_spec.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Audiothority
+  module Validators
+    shared_examples_for 'an uniqueness validator' do
+      let :validator do
+        described_class.new
+      end
+
+      context 'when `field` is unique among given tags' do
+        let :tags do
+          3.times.map { |i| OpenStruct.new(field => 'same') }
+        end
+
+        it 'returns a `valid` validation' do
+          expect(validator.validate(tags)).to be_valid
+        end
+      end
+
+      context 'when `field` is not unique among given tags' do
+        let :tags do
+          3.times.map { |i| OpenStruct.new(field => i) }
+        end
+
+        it 'returns an `invalid` validation' do
+          expect(validator.validate(tags)).to be_invalid
+        end
+
+        it 'indicates which field it is concerned about' do
+          violation = validator.validate(tags)
+          expect(violation.field).to eq(field)
+        end
+
+        it 'reports that there are multiple values for field' do
+          violation = validator.validate(tags)
+          expect(violation.reason).to eq(:multiple)
+        end
+      end
+
+      context 'when `field` is not present among given tags' do
+        let :tags do
+          3.times.map { |i| OpenStruct.new(field => nil) }
+        end
+
+        it 'returns an `invalid` validation' do
+          expect(validator.validate(tags)).to be_invalid
+        end
+
+        it 'indicates which field it is concerned about' do
+          violation = validator.validate(tags)
+          expect(violation.field).to eq(field)
+        end
+
+        it 'reports that field is missing' do
+          violation = validator.validate(tags)
+          expect(violation.reason).to eq(:missing)
+        end
+
+        it 'reports an applicable violation' do
+          violation = validator.validate(tags)
+          expect(violation).to be_applicable
+        end
+      end
+    end
+
+    describe Artist do
+      it_behaves_like 'an uniqueness validator' do
+        let :field do
+          :artist
+        end
+      end
+    end
+
+    describe Album do
+      it_behaves_like 'an uniqueness validator' do
+        let :field do
+          :album
+        end
+      end
+    end
+
+    describe Year do
+      it_behaves_like 'an uniqueness validator' do
+        let :field do
+          :year
+        end
+      end
+    end
+
+    describe TrackNumber do
+      let :validator do
+        described_class.new
+      end
+
+      context 'when `track` is present among all tags' do
+        let :tags do
+          3.times.map { |i| OpenStruct.new(track: i + 1) }
+        end
+
+        it 'returns a `valid` validation' do
+          expect(validator.validate(tags)).to be_valid
+        end
+      end
+
+      context 'when `track` of any tag is zero (0)' do
+        let :tags do
+          3.times.map { |i| OpenStruct.new(track: i) }
+        end
+
+        it 'returns an `invalid` validation' do
+          expect(validator.validate(tags)).to be_invalid
+        end
+
+        it 'indicates which field it is concerned about' do
+          violation = validator.validate(tags)
+          expect(violation.field).to eq(:track)
+        end
+
+        it 'reports one or more tags are missing track numbers' do
+          violation = validator.validate(tags)
+          expect(violation.reason).to eq(:missing)
+        end
+
+        it 'reports a non-applicable violation' do
+          violation = validator.validate(tags)
+          expect(violation).to_not be_applicable
+        end
+      end
+    end
+  end
+end

data/spec/integration/enforce_integration_spec.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+describe 'bin/audiothorian enforce <PATH>' do
+  include_context 'cli setup'
+
+  let :argv do
+    ['enforce', music_dir]
+  end
+
+  context 'when invoked without any paths' do
+    let :argv do
+      ['enforce']
+    end
+
+    it 'prints help for the `enforce` command' do
+      expect { run }.to output(/^Usage:\n.+ enforce/).to_stdout
+    end
+  end
+
+  it 'presents a list of inconsistent albums' do
+    expect do
+      interactive(%w[n]) { run }
+    end.to output(/the-album is inconsistent due to:/).to_stdout
+  end
+
+  context 'when the user answers `y` / `yes` to enforcement' do
+    context ', and selects to perform presented changes' do
+      it 'corrects inconsistencies' do
+        interactive(%w[y P]) { run }
+        tags_from(%(#{music_dir}/the-album)) do |tags|
+          expect(tags.map(&:artist).uniq).to eq(['the artist'])
+          expect(tags.map(&:album).uniq).to eq(['the album'])
+          expect(tags.map(&:year).uniq).to eq([2001])
+        end
+      end
+
+      context 'and -S / --society option is given' do
+        let :society_dir do
+          File.join(music_dir, 'society')
+        end
+
+        let :argv do
+          ['enforce', music_dir, '-S', society_dir]
+        end
+
+        before do
+          Dir.mkdir(society_dir)
+        end
+
+        it 'moves the enforced entity to society' do
+          interactive(%w[y P]) { run }
+          expect(File.exists?(File.join(society_dir, 'the-album'))).to be true
+          tags_from(%(#{society_dir}/the-album)) do |tags|
+            expect(tags.map(&:artist).uniq).to eq(['the artist'])
+            expect(tags.map(&:album).uniq).to eq(['the album'])
+            expect(tags.map(&:year).uniq).to eq([2001])
+          end
+        end
+      end
+    end
+
+    context ', and decides to skip performing changes' do
+      it 'does not apply changes' do
+        interactive(%w[y S]) do
+          expect { run }.to output.to_stdout
+        end
+        tags_from(%(#{music_dir}/the-album)) do |tags|
+          expect(tags.map(&:artist).uniq.size).to be > 1
+          expect(tags.map(&:album).uniq.size).to be > 1
+          expect(tags.map(&:year).uniq.size).to be > 1
+        end
+      end
+    end
+  end
+
+  context 'when the user answer anything else' do
+    it 'terminates and does not change any files' do
+      interactive(%w[n]) do
+        expect { run }.to output.to_stdout
+      end
+      tags_from(%(#{music_dir}/the-album)) do |tags|
+        expect(tags.map(&:artist).uniq.size).to be > 1
+        expect(tags.map(&:album).uniq.size).to be > 1
+        expect(tags.map(&:year).uniq.size).to be > 1
+      end
+    end
+  end
+end

data/spec/integration/scan_integration_spec.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+describe 'bin/audiothorian scan <PATH>' do
+  include_context 'cli setup'
+
+  context 'when invoked without any paths' do
+    let :argv do
+      ['scan']
+    end
+
+    it 'prints help for the `scan` command' do
+      expect { run }.to output(/^Usage:\n.+ scan/).to_stdout
+    end
+  end
+
+  context 'when a directory does not contain inconsistencies' do
+    let :argv do
+      ['scan', empty_dir]
+    end
+
+    let :empty_dir do
+      path = File.join(music_dir, 'empty-dir')
+      Dir.mkdir(path)
+      path
+    end
+
+    it 'prints an `all is good` message' do
+      expect { run }.to output(/All is good/).to_stdout
+    end
+  end
+
+  context 'when a directory contains directories with inconsistencies' do
+    context 'without any options' do
+      let :argv do
+        ['scan', music_dir]
+      end
+
+      it 'scans a given directory and reports inconsistencies' do
+        expect { run }.to output(/the-album is inconsistent due to:/).to_stdout
+      end
+
+      it 'reports inconsistencies in `artist` field' do
+        expect { run }.to output(/multiple artists:/).to_stdout
+      end
+
+      it 'reports inconsistencies in `album` field' do
+        expect { run }.to output(/multiple albums:/).to_stdout
+      end
+
+      it 'reports inconsistencies in `year` field' do
+        expect { run }.to output(/multiple years:/).to_stdout
+      end
+    end
+
+    context 'with --paths-only' do
+      let :argv do
+        ['scan', music_dir, '--paths-only']
+      end
+
+      it 'prints paths to inconsistent albums' do
+        expect { run }.to output(/\/the-album$/).to_stdout
+      end
+    end
+
+    context 'with -C / --custody' do
+      let :custody do
+        File.join(music_dir, 'custody')
+      end
+
+      context ', and custody exists' do
+        before do
+          Dir.mkdir(custody)
+        end
+
+        before do
+          run_audiothorian(['scan', music_dir, '-C', custody])
+        end
+
+        it 'moves suspects into custody' do
+          expect(File.exists?(File.join(music_dir, 'custody', 'the-album'))).to be true
+          expect(Dir[%(#{custody}/**/*.mp3)].size).to eq(3)
+        end
+      end
+
+      context ', and custody does not exist' do
+        it 'raises an error' do
+          expect { run_audiothorian(['scan', music_dir, '-C', custody]) }.to raise_error(Audiothority::CustodyTorchedError)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'tmpdir'
+require 'ostruct'
+require 'support/cli_setup'
+require 'support/interactive'
+require 'coveralls'
+require 'simplecov'
+
+if ENV.include?('TRAVIS')
+  Coveralls.wear!
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+end
+
+SimpleCov.start do
+  add_group 'Source', 'lib'
+  add_group 'Unit tests', 'spec/audiothority'
+  add_group 'Integration tests', 'spec/integration'
+end
+
+require 'audiothority'

data/spec/support/cli_setup.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'fileutils'
+
+
+shared_context 'cli setup' do
+  let :run do
+    run_audiothorian(argv)
+  end
+
+  def run_audiothorian(*argv)
+    Audiothority::Cli.start(*argv)
+  end
+
+  def copy_resources(dir)
+    Dir[resources_glob].each do |path|
+      path = Pathname.new(path)
+      FileUtils.copy_entry(path.to_s, %(#{dir}/#{path.basename}))
+    end
+  end
+
+  def resources_glob
+    %(#{resources_dir}/the-album)
+  end
+
+  def resources_dir
+    @resources_dir ||= File.expand_path('../../resources', __FILE__)
+  end
+
+  def music_dir
+    @music_dir
+  end
+
+  def set_music_dir(dir)
+    @music_dir = dir
+  end
+
+  around do |example|
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        copy_resources(dir)
+        set_music_dir(dir)
+        example.call
+      end
+    end
+  end
+end