audio-feed-manager 0.0.1

data/spec/audio_feed_manager/cli/update_feed_rss_spec.rb

@@ -0,0 +1,26 @@
+module AudioFeedManager
+  describe UpdateFeedRss do
+    fake(:feed_repository)
+    fake(:rss_generator)
+    let(:console) { FakeConsole.new }
+
+    let(:update_feed_rss) { isolate(UpdateFeedRss) }
+
+    it "generates the feed RSS" do
+      feed = build_feed
+      stub(feed_repository).fetch("feeds/foo") { feed }
+
+      update_feed_rss.run(feed: "feeds/foo")
+
+      expect(rss_generator).to have_received.generate(feed)
+    end
+
+    it "prints an error message when feed not found" do
+      stub(feed_repository).fetch("feeds/foo") { raise FeedNotFound.for_id("feeds/foo") }
+
+      update_feed_rss.run(feed: "feeds/foo")
+
+      expect(console.out).to include("not found")
+    end
+  end
+end

data/spec/audio_feed_manager/cli_spec.rb

@@ -0,0 +1,42 @@
+module AudioFeedManager
+  describe CLI do
+    fake(:command, arguments: ArgumentsSpecification.new, name: "init") { InitializeProject }
+    fake(:commands_list)
+    fake(:arguments_parser)
+    fake(:help)
+    fake(:console)
+    let(:arguments) { Arguments.from_hash(project_dir: "my-project-name") }
+
+    let(:cli) { isolate(CLI) }
+
+    it "runs the specified command" do
+      stub(commands_list).get(["init", "my-project-name"]) { [command, ["my-project-name"]]}
+      stub(arguments_parser).parse(command.arguments, ["my-project-name"]) { arguments }
+
+      cli.run(["init", "my-project-name"])
+
+      expect(command).to have_received.run(project_dir: "my-project-name")
+    end
+
+    it "prints command usage if command arguments are invalid and stops the application" do
+      stub(commands_list).get(["init"]) { [command, []]}
+      stub(arguments_parser).parse(command.arguments, []) { raise InvalidArguments }
+
+      expect {
+        cli.run(["init"])
+      }.to raise_error(StopApplication)
+
+      expect(help).to have_received.print_command_usage("init")
+    end
+
+    it "prints usage if command is invalid and stops the application" do
+      stub(commands_list).get(["foo"]) { raise UnknownCommand }
+
+      expect {
+        cli.run(["foo"])
+      }.to raise_error(StopApplication)
+
+      expect(help).to have_received.print_usage
+    end
+  end
+end

data/spec/audio_feed_manager/directory_lister_spec.rb

@@ -0,0 +1,23 @@
+module AudioFeedManager
+  describe DirectoryLister do
+    let(:directory_lister) { isolate(DirectoryLister) }
+
+    it "returns an empty array for non-existent directories" do
+      files = directory_lister.list("/tmp/asdfasdfasdfasdfasdfasdf")
+
+      expect(files).to eq([])
+    end
+
+    it "returns a list of all the files in a given directory, sorted by name" do
+      FileUtils.rm_rf("/tmp/foobar")
+      FileUtils.mkdir_p("/tmp/foobar")
+      FileUtils.touch("/tmp/foobar/foo.txt")
+      FileUtils.touch("/tmp/foobar/bar.txt")
+      FileUtils.touch("/tmp/foobar/baz.txt")
+
+      files = directory_lister.list("/tmp/foobar")
+
+      expect(files).to eq(["bar.txt", "baz.txt", "foo.txt"])
+    end
+  end
+end

data/spec/audio_feed_manager/feed_items_repository_spec.rb

@@ -0,0 +1,34 @@
+module AudioFeedManager
+  describe FeedItemsRepository do
+    let(:items_directory) { Pathname.new("/tmp/foo") }
+    let(:feed_items_repository) { isolate(FeedItemsRepository) }
+    fake(:audio_file_repository)
+
+    before do
+      FileUtils.rm_rf(items_directory)
+      FileUtils.mkdir_p(items_directory)
+    end
+
+    it "returns an empty array for a feed with no items" do
+      feed = build_feed
+
+      expect(feed_items_repository.list(feed)).to eq([])
+    end
+
+    it "returns a list of audio files added for a feed, latest first" do
+      feed = build_feed(id: "feeds/abc")
+      other_feed = build_feed(id: "feeds/def")
+      foo = AudioFile.new(id: "audio_files/foo")
+      bar = AudioFile.new(id: "audio_files/bar")
+      baz = AudioFile.new(id: "audio_files/baz")
+      stub(audio_file_repository).fetch("audio_files/foo") { foo }
+      stub(audio_file_repository).fetch("audio_files/bar") { bar }
+      stub(audio_file_repository).fetch("audio_files/baz") { baz }
+      feed_items_repository.add(feed, foo)
+      feed_items_repository.add(feed, bar)
+      feed_items_repository.add(other_feed, baz)
+
+      expect(feed_items_repository.list(feed)).to eq([bar, foo])
+    end
+  end
+end

data/spec/audio_feed_manager/feeds_repository_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module AudioFeedManager
+  describe FeedRepository do
+    let(:feed_repository) { isolate(FeedRepository) }
+    let(:feeds_directory) { Pathname.new("/tmp/foo/feeds") }
+    let(:feeds_prefix) { "feeds" }
+    fake(:new_model_creator)
+    fake(:storage)
+    fake(:directory_lister)
+
+    it "stores new feeds" do
+      saved_feed = Feed.new(id: "feeds/foo")
+      feed = Feed.new(title: "Hello World!")
+      mock(new_model_creator).create(feed, directory: feeds_directory,
+                                           prefix: feeds_prefix) { saved_feed }
+
+      feed = feed_repository.add(feed)
+    end
+
+    it "fetches the stored feeds" do
+      stub(storage).read("feeds/hello-world") { {id: "feeds/hello-world", title: "Hello World"} }
+
+      expect(feed_repository.fetch("feeds/hello-world")).to eq(Feed.new(id: "feeds/hello-world", title: "Hello World"))
+    end
+
+    it "raises FeedNotFound when a feed by given id does not exist" do
+      stub(storage).read("feeds/hello-world") { raise FileNotFound }
+
+      expect{feed_repository.fetch("feeds/hello-world")}.to raise_error(FeedNotFound)
+    end
+
+    it "lists the feeds" do
+      stub(directory_lister).list(feeds_directory) { ["hello-world"] }
+      stub(storage).read("feeds/hello-world") { {id: "feeds/hello-world", title: "Hello World"} }
+
+      expect(feed_repository.list).to include(Feed.new(id: "feeds/hello-world", title: "Hello World"))
+    end
+  end
+end

data/spec/audio_feed_manager/file_storage_spec.rb

@@ -0,0 +1,22 @@
+module AudioFeedManager
+  describe FileStorage do
+    let(:directory) { Pathname.new("/tmp/foo") }
+
+    let(:storage) { isolate(FileStorage) }
+
+    before do
+      FileUtils.rm_rf(directory)
+      FileUtils.mkdir_p(directory.join("feeds"))
+    end
+
+    it "stores the contents in a specified file" do
+      storage.store("feeds/hello", {id: 1, title: "hello!"})
+
+      expect(storage.read("feeds/hello")).to eq(id: 1, title: "hello!")
+    end
+
+    it "raises an error, when the given file does not exist" do
+      expect{ storage.read("feeds/hello") }.to raise_error(FileNotFound)
+    end
+  end
+end

data/spec/audio_feed_manager/id3_tags_spec.rb

@@ -0,0 +1,26 @@
+module AudioFeedManager
+  describe Id3Tags do
+    let(:id3tags) { isolate(Id3Tags) }
+
+    it "reads ID3 tags from an mp3 file" do
+      tags = id3tags.read(fixture_file("test.mp3"))
+
+      expect(tags.title).to eq("My first audio file")
+      expect(tags.artist).to eq("Adam Pohorecki")
+    end
+
+    it "returns empty tags for a file that does not exist" do
+      tags = id3tags.read(Pathname.new("/tmp/file-which-does-not-exist"))
+
+      expect(tags.title).to eq(nil)
+      expect(tags.artist).to eq(nil)
+    end
+
+    it "returns empty tags for a file that is not an mp3 file" do
+      tags = id3tags.read(fixture_file("test.txt"))
+
+      expect(tags.title).to eq(nil)
+      expect(tags.artist).to eq(nil)
+    end
+  end
+end

data/spec/audio_feed_manager/new_model_creator_spec.rb

@@ -0,0 +1,44 @@
+module AudioFeedManager
+  describe NewModelCreator do
+    class SampleModel < Struct.new(:id, :title, :secret_token, :foo)
+      include HashConstructor
+    end
+
+    let(:new_model_creator) { isolate(NewModelCreator) }
+    let(:directory) { Pathname.new("/tmp/foo/feeds") }
+    let(:prefix) { "feeds" }
+    fake(:unique_id_generator, generate: "hello-world")
+    fake(:secret_token_generator, generate: "secret-token")
+    fake(:storage)
+
+    it "sets the id for the added model" do
+      stub(unique_id_generator).generate("Hello World!", directory) { "hello-world" }
+      model = SampleModel.new(title: "Hello World!")
+
+      new_model_creator.create(model, prefix: prefix, directory: directory)
+
+      expect(model.id).to eq("feeds/hello-world")
+    end
+
+    it "stores the added model" do
+      model = SampleModel.new(title: "Hello World!", foo: "hello there")
+
+      new_model_creator.create(model, prefix: prefix, directory: directory)
+
+      expect(storage).to have_received.store(
+        "feeds/hello-world",
+        id: "feeds/hello-world",
+        title: "Hello World!",
+        secret_token: "secret-token",
+        foo: "hello there",
+      )
+    end
+
+    it "assigns a secret token to the created model" do
+      model = new_model_creator.create(SampleModel.new(title: "Hello World!"), prefix: prefix, directory: directory)
+
+      expect(model.secret_token).to eq("secret-token")
+    end
+
+  end
+end

data/spec/audio_feed_manager/rss_repository_spec.rb

@@ -0,0 +1,34 @@
+module AudioFeedManager
+  describe RSSRepository do
+    fake(:url_maker, feed_url: "http://example.com/feed.xml", audio_file_url: "http://example.com/audio/foo.mp3")
+    let(:rss_files_directory) { Pathname.new("/tmp/my-project/rss") }
+
+    before do
+      FileUtils.rm_rf(rss_files_directory)
+      FileUtils.mkdir_p(rss_files_directory)
+    end
+
+    it "stores an RSS feed under rss/:secret_token.xml" do
+      feed = build_feed(id: "feeds/hello",
+                        title: "My First Feed",
+                        description: "some description",
+                        secret_token: "abcdefgh")
+      audio_file = build_audio_file(secret_token: "foobar",
+                                    extension: ".mp3",
+                                    title: "Some audio file",
+                                    author: "Audio file author")
+      rss_repository = isolate(RSSRepository)
+
+      rss_repository.store(feed, [audio_file])
+
+      feed_content = File.read("/tmp/my-project/rss/abcdefgh.xml")
+      expect(feed_content).to include("<?xml")
+      expect(feed_content).to include("My First Feed")
+      expect(feed_content).to include("some description")
+      expect(feed_content).not_to include("feeds/hello")
+      expect(feed_content).to include("Some audio file")
+      expect(feed_content).to include("Audio file author")
+      expect(feed_content).to include("http://example.com/audio/foo.mp3")
+    end
+  end
+end

data/spec/audio_feed_manager/s3_gateway_spec.rb

@@ -0,0 +1,51 @@
+require 'net/http'
+
+module AudioFeedManager
+  describe S3Gateway, :slow do
+    let(:config) { Config.new(s3_bucket: s3_config["bucket"],
+                             s3_access_key: s3_config["access_key"],
+                             s3_secret: s3_config["secret_key"],
+                             s3_region: s3_config["region"]) }
+
+    let(:s3_gateway) { isolate(S3Gateway) }
+
+    it "syncs files to S3" do
+      unique_key = "test/#{SecureRandom.hex}"
+      file_name = :not_called
+
+      s3_gateway.sync(unique_key, fixture_file("test.mp3")) { |f| file_name = f }
+
+      expect(file_name).to eq(unique_key)
+    end
+
+    it "does not sync the same file twice" do
+      unique_key = "test/#{SecureRandom.hex}"
+      file_name = :not_called
+
+      s3_gateway.sync(unique_key, fixture_file("test.mp3"))
+      s3_gateway.sync(unique_key, fixture_file("test.mp3")) { |f| file_name = f }
+
+      expect(file_name).to eq(:not_called)
+    end
+
+    it "syncs the same file twice if the contents change" do
+      unique_key = "test/#{SecureRandom.hex}"
+      file_name = :not_called
+
+      s3_gateway.sync(unique_key, fixture_file("test.mp3"))
+      s3_gateway.sync(unique_key, fixture_file("test.txt")) { |f| file_name = f }
+
+      expect(file_name).to eq(unique_key)
+    end
+
+    it "makes the file publicly accessible" do
+      unique_key = "test/#{SecureRandom.hex}"
+
+      s3_gateway.sync(unique_key, fixture_file("test.txt"))
+
+      url = URI.parse(s3_gateway.url(unique_key))
+      content = File.read(fixture_file("test.txt"))
+      expect(Net::HTTP.get(url)).to eq(content)
+    end
+  end
+end

data/spec/audio_feed_manager/secret_token_generator_spec.rb

@@ -0,0 +1,13 @@
+module AudioFeedManager
+  describe SecretTokenGenerator do
+    let(:generator) { isolate(SecretTokenGenerator) }
+
+    it "generates 16-character strings" do
+      expect(generator.generate.size).to eq(16)
+    end
+
+    it "generates unique strings" do
+      expect(generator.generate).not_to eq(generator.generate)
+    end
+  end
+end

data/spec/audio_feed_manager/support/getter_setter_method_spec.rb

@@ -0,0 +1,77 @@
+module AudioFeedManager
+  describe GetterSetterMethod do
+    context "without a default value" do
+      klass = Class.new do
+        extend GetterSetterMethod
+
+        get_set :foo
+        get_set :bar
+      end
+
+      it "returns nil by default" do
+        instance = klass.new
+
+        expect(instance.foo).to be_nil
+        expect(instance.bar).to be_nil
+      end
+
+      it "sets the value when value given" do
+        instance = klass.new
+
+        instance.foo "bar"
+
+        expect(instance.foo).to eq("bar")
+      end
+
+      it "does not overwrite other values when setting one property" do
+        instance = klass.new
+
+        instance.foo "bar"
+
+        expect(instance.bar).to be_nil
+      end
+    end
+
+    context "with a default value" do
+      klass = Class.new do
+        extend GetterSetterMethod
+
+        get_set(:foo) { bar }
+        get_set :bar
+        get_set(:baz) { "hello" }
+      end
+
+      it "returns the default value" do
+        instance = klass.new
+
+        expect(instance.baz).to eq("hello")
+      end
+
+      it "overwrites the value when value given" do
+        instance = klass.new
+
+        instance.baz "aaa"
+
+        expect(instance.baz).to eq("aaa")
+      end
+
+      it "evaluates the default block lazily" do
+        instance = klass.new
+
+        instance.bar "aaa"
+
+        expect(instance.foo).to eq("aaa")
+      end
+
+      it "caches the value once set" do
+        instance = klass.new
+
+        instance.bar "aaa"
+        instance.foo
+        instance.bar "bbb"
+
+        expect(instance.foo).to eq("aaa")
+      end
+    end
+  end
+end

data/spec/audio_feed_manager/unique_id_generator_spec.rb

@@ -0,0 +1,23 @@
+module AudioFeedManager
+  describe UniqueIdGenerator do
+    fake(:directory_lister)
+
+    let(:generator) { isolate(UniqueIdGenerator) }
+
+    it "generates ids based on the given name" do
+      stub(directory_lister).list("/foo") { [] }
+
+      id = generator.generate("Hello World!", "/foo")
+
+      expect(id).to eq("hello-world")
+    end
+
+    it "suffixes the id with a number if the name is not unique" do
+      stub(directory_lister).list("/foo") { ["hello-world", "foo-bar"] }
+
+      id = generator.generate("Hello World!", "/foo")
+
+      expect(id).to eq("hello-world-1")
+    end
+  end
+end

data/spec/fixtures/test.txt

@@ -0,0 +1 @@
+Hello!

data/spec/help_spec.rb

@@ -0,0 +1,64 @@
+require 'stringio'
+
+describe "help commands" do
+  let(:stdin) { StringIO.new }
+  let(:stderr) { StringIO.new }
+
+  it "prints help when no arguments given" do
+    AudioFeedManager.run(
+      argv: [],
+      stdin: stdin,
+      stderr: stderr,
+    )
+
+    expect(stderr.string).to include("Usage:")
+    expect(stderr.string).to include("init")
+  end
+
+  it "prints help with the help command" do
+    AudioFeedManager.run(
+      argv: ["help"],
+      stdin: stdin,
+      stderr: stderr,
+    )
+
+    expect(stderr.string).to include("Usage:")
+    expect(stderr.string).to include("init")
+  end
+
+  it "prints help with an unknown command" do
+    AudioFeedManager.run(
+      argv: ["asdfasdfa"],
+      stdin: stdin,
+      stderr: stderr,
+      exit: ->(out) {}
+    )
+
+    expect(stderr.string).to include("Usage:")
+    expect(stderr.string).to include("init")
+  end
+
+  it "prints help for specific commands" do
+    AudioFeedManager.run(
+      argv: ["help", "init"],
+      stdin: stdin,
+      stderr: stderr,
+    )
+
+    expect(stderr.string).to include("Usage:")
+    expect(stderr.string).to include("init")
+    expect(stderr.string).to include("<PROJECT_DIR>")
+  end
+
+  it "prints help for multi-word commands" do
+    AudioFeedManager.run(
+      argv: ["help", "feeds", "add"],
+      stdin: stdin,
+      stderr: stderr,
+    )
+
+    expect(stderr.string).to include("Usage:")
+    expect(stderr.string).to include("feeds add")
+    expect(stderr.string).to include("<TITLE>")
+  end
+end

data/spec/initializing_spec.rb

@@ -0,0 +1,12 @@
+describe "Initializing project" do
+  it "creates the project directory and some support files/directories" do
+    FileUtils.rm_rf("/tmp/my-test-project")
+
+    init_project("/tmp/my-test-project")
+
+    expect(File.exists?("/tmp/my-test-project")).to be(true)
+    expect(File.exists?("/tmp/my-test-project/feeds")).to be(true)
+    expect(File.exists?("/tmp/my-test-project/audio_files")).to be(true)
+    expect(File.exists?("/tmp/my-test-project/config.yml")).to be(true)
+  end
+end

data/spec/managing_audio_files_spec.rb

@@ -0,0 +1,21 @@
+describe "Managing audio files" do
+  it "adds audio files to feeds" do
+    dir = init_project
+    feed = add_feed(dir)
+
+    AudioFeedManager.run(
+      pwd: dir,
+      stdout: StringIO.new,
+      argv: ["audio", "add", feed.id, fixture_file("test.mp3")]
+    )
+
+    out = StringIO.new
+    AudioFeedManager.run(
+      pwd: dir,
+      stdout: out,
+      argv: ["feeds", "show", feed.id]
+    )
+
+    expect(out.string).to include("My first audio file")
+  end
+end

data/spec/managing_feeds_spec.rb

@@ -0,0 +1,51 @@
+describe "Managing Feeds" do
+  it "adds feeds using afm feeds add" do
+    dir = init_project
+
+    AudioFeedManager.run(
+      pwd: dir,
+      stdin: StringIO.new("some description"),
+      stdout: StringIO.new,
+      argv: ["feeds", "add", "Hello World!"]
+    )
+
+    stdout = StringIO.new
+    AudioFeedManager.run(
+      pwd: dir,
+      argv: ["feeds", "list"],
+      stdout: stdout,
+    )
+
+    expect(stdout.string).to include("Hello World!")
+  end
+
+  it "allows getting the feed url" do
+    dir = init_project
+    feed = add_feed(dir)
+
+    out = StringIO.new
+    AudioFeedManager.run(
+      pwd: dir,
+      stdout: out,
+      argv: ["feeds", "get-url", feed.id]
+    )
+
+    expect(out.string).to include("http")
+  end
+
+  it "allows regenerating feed rss" do
+    dir = init_project
+    feed = add_feed(dir)
+
+    rss_files = File.join(dir, "rss/*.xml")
+    Dir[rss_files].each{|f| FileUtils.rm_rf(f)}
+
+    AudioFeedManager.run(
+      pwd: dir,
+      stdout: StringIO.new,
+      argv: ["feeds", "update-rss", feed.id]
+    )
+
+    expect(Dir[rss_files]).not_to eq([])
+  end
+end

data/spec/publishing_spec.rb

@@ -0,0 +1,24 @@
+require 'net/http'
+
+describe "Publishing content to S3", :slow do
+  it "publishes the RSS and data files" do
+    dir = init_project
+    feed = add_feed(dir)
+    add_audio_file(dir, feed)
+
+    AudioFeedManager.run(
+      pwd: dir,
+      stdout: StringIO.new,
+      argv: ["publish"]
+    )
+
+    AudioFeedManager.run(
+      pwd: dir,
+      stdout: out = StringIO.new,
+      argv: ["feeds", "get-url", feed.id]
+    )
+    feed_url = out.string.chomp
+
+    expect(Net::HTTP.get(URI.parse(feed_url))).to include("Hello World!")
+  end
+end

data/spec/s3_credentials.yml.sample

@@ -0,0 +1,5 @@
+---
+secret_key: "SECRET"
+access_key: "ACCESS"
+bucket: "BUCKET"
+region: "us-west-2"

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'audio-feed-manager'
+require 'bogus/rspec'
+require 'dependor/rspec'
+require "fileutils"
+
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each do |file|
+  require file
+end
+
+Bogus.configure do |config|
+  config.search_modules = [AudioFeedManager]
+end
+
+RSpec.configure do |config|
+  config.include IntegrationHelpers
+  config.include Builders
+end