itunes-connect 0.9.0

data/lib/itunes_connect/rc_file.rb

@@ -0,0 +1,30 @@
+require "yaml"
+
+class ItunesConnect::RcFile          # :nodoc:
+
+  DEFAULT_RCFILE_PATH = File.expand_path("~/.itunesrc")
+
+  def self.default
+    self.new(DEFAULT_RCFILE_PATH)
+  end
+
+  def initialize(path=DEFAULT_RCFILE_PATH)
+    if File.exist?(path)
+      @rc = YAML.load_file(path)
+    else
+      @rc = { }
+    end
+  end
+
+  def username
+    @rc[:username]
+  end
+
+  def password
+    @rc[:password]
+  end
+
+  def database
+    @rc[:database]
+  end
+end

data/lib/itunes_connect/report.rb

@@ -0,0 +1,56 @@
+require "ostruct"
+
+# This class transforms the raw input given in the constructor into a
+# series of objects representing each row. You can either get the
+# entire set of data by accessing the +data+ attribute, or by calling
+# the +each+ method and handing it a block.
+class ItunesConnect::Report
+  include Enumerable
+
+  # The report as a Hash, where the keys are country codes and the
+  # values are Hashes with the keys, <tt>:date</tt>, <tt>:upgrade</tt>,
+  # <tt>:install</tt>.
+  attr_reader :data
+
+  # Give me an +IO+-like object (one that responds to the +each+
+  # method) and I'll parse that sucker for you.
+  def initialize(input)
+    @data = Hash.new { |h,k| h[k] = { }}
+    input.each do |line|
+      line.chomp!
+      next if line =~ /^(Provider|$)/
+      tokens = line.split(/\s+/)
+      country = tokens[11]
+      count = tokens[6].to_i
+      @data[country][:date] = Date.parse(tokens[8])
+      case tokens[5].to_i
+      when 7
+        @data[country][:upgrade] = count
+      when 1
+        @data[country][:install] = count
+      end
+    end
+  end
+
+  # Yields each parsed data row to the given block. Each item yielded
+  # has the following attributes:
+  #   * country
+  #   * date
+  #   * install_count
+  #   * upgrade_count
+  def each                      # :yields: record
+    @data.each do |country, value|
+      if block_given?
+        yield OpenStruct.new(:country => country,
+                             :date => value[:date],
+                             :install_count => value[:install] || 0,
+                             :upgrade_count => value[:upgrade] || 0)
+      end
+    end
+  end
+
+  # The total number of rows in the report
+  def size
+    @data.size
+  end
+end

data/lib/itunes_connect/store.rb

@@ -0,0 +1,129 @@
+require "sqlite3"
+require "ostruct"
+
+module ItunesConnect
+  # Represents a database stored on disk.
+  class Store
+    # Creates a new instance. If no database file exists at the given
+    # path a new one is created and the correct tables and indexes are
+    # added.
+    def initialize(file, verbose=false)
+      @db = SQLite3::Database.new(file)
+      if @db.table_info("reports").empty?
+        @db.execute("CREATE TABLE reports (id INTEGER PRIMARY KEY, " +
+                    "report_date DATE, country TEXT, install_count INTEGER, " +
+                    "update_count INTEGER)")
+        @db.execute("CREATE UNIQUE INDEX u_reports_idx ON reports " +
+                    "(report_date, country)")
+      end
+      @verbose = verbose
+    end
+
+    def verbose?                # :nodoc:
+      !!@verbose
+    end
+
+    # Add a record to this instance
+    def add(date, country, install_count, update_count)
+      @db.execute("INSERT INTO reports (report_date, country, " +
+                  "install_count, update_count) VALUES (?, ?, ?, ?)",
+                  date, country, install_count, update_count)
+      true
+    rescue SQLite3::SQLException => e
+      if e.message =~ /columns .* are not unique/
+        $stdout.puts "Skipping existing row for #{country} on #{date}" if verbose?
+        false
+      else
+        raise e
+      end
+    end
+
+    VALID_COUNT_OPTIONS = [:from, :to, :country]
+    # Get counts optionally constrained by dates and/or country codes.
+    # Available options are:
+    # <tt>:from</tt>:: The from date, defaults to the beginning
+    # <tt>:to</tt>:: The end date, defaults to now
+    # <tt>:country</tt>:: The country code, defaults to <tt>nil</tt>
+    # which means no country code restriction
+    def counts(opts={ })
+      unless (leftovers = opts.keys - VALID_COUNT_OPTIONS).empty?
+        raise "Invalid keys: #{leftovers.join(', ')}"
+      end
+
+      params = []
+      clauses = []
+      sql = "SELECT * FROM reports"
+
+      if opts[:from]
+        clauses << "report_date >= ?"
+        params << opts[:from]
+      end
+
+      if opts[:to]
+        clauses << "report_date <= ?"
+        params << opts[:to]
+      end
+
+      if opts[:country]
+        clauses << "country = ?"
+        params << opts[:country]
+      end
+
+      sql << " WHERE " unless clauses.empty?
+      sql << clauses.join(" AND ") unless params.empty?
+      sql << " ORDER BY report_date DESC"
+
+      @db.execute(sql, *params).map do |row|
+        OpenStruct.new({
+                         :report_date => Date.parse(row[1]),
+                         :country => row[2],
+                         :install_count => row[3].to_i,
+                         :update_count => row[4].to_i
+                       })
+      end
+    end
+
+    # Get summed counts by country, optionally constrained by dates
+    # and/or country codes. Available options are:
+    # <tt>:from</tt>:: The from date, defaults to the beginning
+    # <tt>:to</tt>:: The end date, defaults to now
+    # <tt>:country</tt>:: The country code, defaults to <tt>nil</tt>
+    # which means no country code restriction
+    def country_counts(opts={ })
+      unless (leftovers = opts.keys - VALID_COUNT_OPTIONS).empty?
+        raise "Invalid keys: #{leftovers.join(', ')}"
+      end
+
+      params = []
+      clauses = []
+      sql = "SELECT country, SUM(install_count), SUM(update_count) FROM reports"
+
+      if opts[:from]
+        clauses << "report_date >= ?"
+        params << opts[:from]
+      end
+
+      if opts[:to]
+        clauses << "report_date <= ?"
+        params << opts[:to]
+      end
+
+      if opts[:country]
+        clauses << "country = ?"
+        params << opts[:country]
+      end
+
+      sql << " WHERE " unless clauses.empty?
+      sql << clauses.join(" AND ") unless params.empty?
+      sql << " GROUP BY country ORDER BY country"
+
+      @db.execute(sql, *params).map do |row|
+        OpenStruct.new({
+                         :country => row[0],
+                         :install_count => row[1].to_i,
+                         :update_count => row[2].to_i
+                       })
+      end
+    end
+  end
+end

data/spec/commands/download_spec.rb

@@ -0,0 +1,140 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ItunesConnect::Commands::Download do
+  before(:each) do
+    @cmd = ItunesConnect::Commands::Download.new(mock(:null_object => true),
+                                            mock(:username => nil,
+                                                 :password => nil,
+                                                 :database => nil))
+    @defaults = {
+      :username => 'dudeman',
+      :password => 'sekret',
+      :date => nil,
+      :out => nil,
+      :db => nil,
+      :verbose? => false,
+      :debug? => false,
+      :report => 'Daily'
+    }
+  end
+
+  describe 'with valid execution arguments' do
+    before(:each) do
+      @connection = mock(ItunesConnect::Connection)
+      ItunesConnect::Connection.should_receive(:new).
+        with('dudeman', 'sekret', false, false).
+        and_return(@connection)
+    end
+
+    it 'should call get_report correctly with no args' do
+      @connection.should_receive(:get_report).with(Date.today - 1, $stdout, 'Daily')
+      opts = stub(@defaults)
+      @cmd.execute!(opts)
+    end
+
+    it 'should call get_report with date argument when given' do
+      today = Date.today - 15
+      @connection.should_receive(:get_report).with(today, $stdout, 'Daily')
+      opts = stub(@defaults.merge(:date => today))
+      @cmd.execute!(opts)
+    end
+
+    it 'should call get_report with File object when path is given' do
+      @connection.should_receive(:get_report).with(Date.today - 1,
+                                                an_instance_of(File),
+                                                'Daily')
+      opts = stub(@defaults.merge(:out => '/tmp/foobar'))
+      @cmd.execute!(opts)
+    end
+
+    it 'should use the given report type' do
+      @connection.should_receive(:get_report).with(Date.today - 1, $stdout, 'Weekly')
+      opts = stub(@defaults.merge({ :report => 'Weekly' }))
+      @cmd.execute!(opts)
+    end
+
+    describe 'and the :db option is specified' do
+      it 'should import the results into the DB' do
+        t = Date.parse('8/31/2009')
+        @connection.should_receive(:get_report) do |date, io, report|
+          io << read_fixture('fixtures/report.txt')
+          io.flush
+        end
+
+        store = mock(ItunesConnect::Store)
+        store.should_receive(:add).with(t, 'GB', 0, 1)
+        store.should_receive(:add).with(t, 'AR', 0, 1)
+        store.should_receive(:add).with(t, 'US', 1, 3)
+        ItunesConnect::Store.should_receive(:new).
+          with('/tmp/foobar.db', false).
+          and_return(store)
+
+        opts = stub(@defaults.merge(:db => '/tmp/foobar.db',
+                                    :date => '2009/08/31'))
+        @cmd.execute!(opts)
+      end
+    end
+  end
+
+  describe 'checking execution arguments' do
+    it 'should get grumpy when no username or password is given' do
+      lambda { @cmd.execute! }.should raise_error(ArgumentError)
+      lambda { @cmd.execute!(stub(@defaults.merge(:password => nil))) }.
+        should raise_error(ArgumentError)
+
+      lambda { @cmd.execute!(stub(@defaults.merge(:username => nil))) }.
+        should raise_error(ArgumentError)
+    end
+
+    it 'should reject getting both :out and :db options' do
+      lambda do
+        opts = stub(@defaults.merge(:db => '/tmp/foobar.db',
+                                    :out => '/tmp/foobar.txt'))
+        @cmd.execute!(opts)
+      end.should raise_error(ArgumentError)
+    end
+
+    it 'should reject invalid report types' do
+      lambda do
+        opts = stub(@defaults.merge(:report => 'Glowing'))
+        @cmd.execute!(opts)
+      end.should raise_error(ArgumentError)
+    end
+
+    it 'should reject requests to store monthly reports in the database' do
+      lambda do
+        opts = stub(@defaults.merge(:report => 'Monthly', :db => '/tmp/foo.db'))
+        @cmd.execute!(opts)
+      end.should raise_error(ArgumentError)
+    end
+  end
+
+  describe 'setting up command-line options' do
+    it 'should add appropriate options to given Clip' do
+      clip = mock('Clip')
+      clip.should_receive(:opt).
+        with('u', 'username',
+             :desc => 'iTunes Connect username')
+      clip.should_receive(:opt).
+        with('p', 'password',
+             :desc => 'iTunes Connect password')
+      clip.should_receive(:opt).
+        with('d', 'date',
+             :desc => 'Daily report date (MM/DD/YYYY format)',
+             :default => (Date.today - 1).strftime('%m/%d/%Y'))
+      clip.should_receive(:opt).
+        with('o', 'out',
+             :desc => 'Dump report to file, - is stdout')
+      clip.should_receive(:opt).
+        with('b', 'db',
+             :desc => 'Dump report to sqlite DB at the given path')
+      clip.should_receive(:opt).
+        with('r', 'report',
+             :desc => 'Report type. One of "Daily", "Weekly", "Monthly"',
+             :default => 'Daily')
+
+      ItunesConnect::Commands::Download.new(clip)
+    end
+  end
+
+end

data/spec/commands/help_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "clip"
+
+describe ItunesConnect::Commands::Help do
+  before(:each) do
+    @cmd = ItunesConnect::Commands::Help.new(mock(:null_object => true))
+  end
+
+  describe 'with valid execution arguments' do
+    before(:each) do
+      @io = StringIO.new
+    end
+
+    it 'should dump the "download" command usage to :out' do
+      @cmd.execute!(nil, %w(download), @io)
+      clip = ItunesConnect::Commands.default_clip
+      clip.banner = "Command options for 'download':"
+      ItunesConnect::Commands::Download.new(clip)
+      @io.string.should == clip.help
+    end
+
+    it 'should dump the "import" command usage to :out' do
+      @cmd.execute!(nil, %w(import), @io)
+      clip = ItunesConnect::Commands.default_clip
+      clip.banner = "Command options for 'import':"
+      ItunesConnect::Commands::Import.new(clip)
+      @io.string.should == clip.help
+    end
+
+    it 'should dump the "report" command usage to :out' do
+      @cmd.execute!(nil, %w(report), @io)
+      clip = ItunesConnect::Commands.default_clip
+      clip.banner = "Command options for 'report':"
+      ItunesConnect::Commands::Report.new(clip)
+      @io.string.should == clip.help
+    end
+  end
+
+  describe 'when no command name is given' do
+    it 'should raise an ArgumentError' do
+      io = StringIO.new
+      @cmd.execute!(nil, [], io)
+      io.string.should == <<-EOF
+Available commands:
+
+download  Retrieves reports from the iTunes Connect site
+import    Imports report data into a database file
+report    Generates reports from a local database
+help      Describe a particular command
+EOF
+
+    end
+  end
+
+  describe 'when usage is requested for an unrecognized command' do
+
+    it 'should raise an ArgumentError' do
+      lambda { @cmd.execute!({ :out => @io }, %w(bazooka)) }.
+        should raise_error(ArgumentError)
+    end
+
+  end
+
+end

data/spec/commands/import_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "tempfile"
+
+describe ItunesConnect::Commands::Import do
+
+  before(:each) do
+    @cmd = ItunesConnect::Commands::Import.new(mock(:null_object => true),
+                                          mock(:username => nil,
+                                               :password => nil,
+                                               :database => nil))
+  end
+
+  describe 'with valid execution arguments' do
+    before(:each) do
+      @store = mock(ItunesConnect::Store)
+      ItunesConnect::Store.should_receive(:new).
+        with("/tmp/store.db", false).
+        and_return(@store)
+    end
+
+    it 'should add a record to the store for each row of data' do
+      t = Date.parse('8/31/2009')
+      @store.should_receive(:add).with(t, 'GB', 0, 1)
+      @store.should_receive(:add).with(t, 'AR', 0, 1)
+      @store.should_receive(:add).with(t, 'US', 1, 3)
+      report_file = File.join(File.dirname(__FILE__), '..', 'fixtures', 'report.txt')
+      @cmd.execute!(stub(:db => '/tmp/store.db',
+                         :file => report_file,
+                         :verbose? => false))
+    end
+  end
+
+  describe 'execution argument validation' do
+    it 'should reject missing all options' do
+      lambda { @cmd.execute! }.should raise_error(ArgumentError)
+    end
+
+    it 'should reject missing :file option' do
+      lambda do
+        @cmd.execute!(stub(:db => '/tmp/store.db', :file => nil))
+      end.should raise_error(ArgumentError)
+    end
+
+    it 'should reject missing :db option' do
+      lambda do
+        @cmd.execute!(stub(:db => nil, :file => '/tmp/report.txt', :verbose? => false))
+      end.should raise_error(ArgumentError)
+    end
+  end
+
+  describe 'setting up command-line parsing' do
+
+    it 'should add appropriate options to a given Clip' do
+      clip = mock('Clip')
+      clip.should_receive(:opt).
+        with('b', 'db',
+             :desc => 'Dump report to sqlite DB at the given path')
+      clip.should_receive(:req).
+        with('f', 'file',
+             :desc => 'The file to import, - means standard in')
+
+      ItunesConnect::Commands::Import.new(clip)
+    end
+  end
+
+end