lita-forecast 0.1.0

data/lita-forecast.gemspec

@@ -0,0 +1,34 @@
+# -*- coding: UTF-8 -*-
+require 'English'
+
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+
+require 'lita-forecast/version'
+
+Gem::Specification.new do |g|
+  g.name        = 'lita-forecast'
+  g.version     = LitaForecast::VERSION
+  g.date        = Time.now.strftime('%Y-%m-%d')
+  g.description = 'Lita plugin for Forecast.io'
+  g.summary     = 'Lita + Forecast.io'
+  g.authors     = ['Tim Heckman']
+  g.email       = 't@heckman.io'
+  g.homepage    = 'https://github.com/theckman/lita_forecast'
+  g.license     = 'MIT'
+
+  g.test_files  = %x(git ls-files spec/*).split
+  g.files       = %x(git ls-files).split
+
+  g.add_development_dependency 'bundler', '~> 1.5'
+  g.add_development_dependency 'rake', '~> 10.1.0'
+  g.add_development_dependency 'rubocop', '~> 0.19.1'
+  g.add_development_dependency 'rspec', '>= 3.0.0.beta2'
+  g.add_development_dependency 'fuubar', '~> 1.3.2'
+  g.add_development_dependency 'coveralls', '~> 0.7.0'
+  g.add_development_dependency 'simplecov', '~> 0.8.2'
+
+  g.add_runtime_dependency 'lita', '~>3.0.0'
+  g.add_runtime_dependency 'forecast_io', '~>2.0.0'
+  g.add_runtime_dependency 'geocoder', '~>1.1.9'
+  g.add_runtime_dependency 'compass_rose', '~> 0.1.0'
+end

data/spec/lita/handlers/forecast/current_spec.rb

@@ -0,0 +1,264 @@
+# -*- coding: UTF-8 -*-
+require 'spec_helper'
+
+describe LitaForecast::Current do
+  let(:forecast) do
+    {
+      'currently' => {
+        'temperature' => 100.11,
+        'apparentTemperature' => 102.11,
+        'summary' => 'weather',
+        'windBearing' => 0,
+        'windSpeed' => 5.11,
+        'humidity' => 0.10,
+        'dewPoint' => 20.11,
+        'pressure' => 1020.11,
+        'cloudCover' => 0.01
+      },
+      'minutely' => { 'summary' => 'minutely weather' },
+      'hourly' => { 'summary' => 'hourly weather' },
+      'flags' => { 'units' => 'us' }
+    }
+  end
+  let(:current) { described_class.new(forecast) }
+
+  describe '#new' do
+    context 'when given more than one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          LitaForecast::Current.new(nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          LitaForecast::Current.new
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when provided valid arguments' do
+      subject { LitaForecast::Current.new(forecast) }
+
+      it { should be_an_instance_of LitaForecast::Current }
+
+      it 'should set the f instance variable' do
+        expect(subject.instance_variable_get(:@f)).to eql forecast
+      end
+    end
+  end
+
+  describe '.currently' do
+    context 'when given one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          current.send(:currently, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed no args' do
+      subject { current.send(:currently) }
+
+      it { should be_an_instance_of Hash }
+
+      it { should eql forecast['currently'] }
+    end
+  end
+
+  describe '.temp' do
+    context 'when given one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          current.send(:temp, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed no args' do
+      subject { current.send(:temp) }
+      let(:temp) { '100.1F' }
+
+      it { should be_an_instance_of String }
+
+      it { should eql temp }
+    end
+  end
+
+  describe '.feels' do
+    context 'when given one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          current.send(:feels, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed no args' do
+      subject { current.send(:feels) }
+      let(:feels) { '102.1F' }
+
+      it { should be_an_instance_of String }
+
+      it { should eql feels }
+    end
+  end
+
+  describe '.wind' do
+    context 'when given one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          current.send(:wind, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed no args' do
+      subject { current.send(:wind) }
+      let(:wind) { 'N 5.1mph' }
+
+      it { should be_an_instance_of String }
+
+      it { should eql wind }
+    end
+  end
+
+  describe '.humidity' do
+    context 'when given one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          current.send(:humidity, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed no args' do
+      subject { current.send(:humidity) }
+      let(:humidity) { '10%' }
+
+      it { should be_an_instance_of String }
+
+      it { should eql humidity }
+    end
+  end
+
+  describe '.dew_pt' do
+    context 'when given one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          current.send(:dew_pt, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed no args' do
+      subject { current.send(:dew_pt) }
+      let(:dew_pt) { '20.1F' }
+
+      it { should be_an_instance_of String }
+
+      it { should eql dew_pt }
+    end
+  end
+
+  describe '.pressure' do
+    context 'when given one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          current.send(:pressure, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed no args' do
+      subject { current.send(:pressure) }
+      let(:pressure) { '1020.1mb' }
+
+      it { should be_an_instance_of String }
+
+      it { should eql pressure }
+    end
+  end
+
+  describe '.clouds' do
+    context 'when given one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          current.send(:clouds, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed no args' do
+      subject { current.send(:clouds) }
+      let(:clouds) { '1%' } # these clouds are the 1%... (horrible joke) //TH
+
+      it { should be_an_instance_of String }
+
+      it { should eql clouds }
+    end
+  end
+
+  describe '.next_hour' do
+    context 'when given one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          current.send(:next_hour, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed no args' do
+      subject { current.send(:next_hour) }
+      let(:next_hour) { 'minutely weather' }
+
+      it { should be_an_instance_of String }
+
+      it { should eql next_hour }
+    end
+  end
+
+  describe '.today' do
+    context 'when given one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          current.send(:today, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed no args' do
+      subject { current.send(:today) }
+      let(:today) { 'hourly weather' }
+
+      it { should be_an_instance_of String }
+
+      it { should eql today }
+    end
+  end
+
+  describe '.conditions' do
+    subject { LitaForecast::Current.new(forecast).conditions }
+    let(:fc_string) do
+      '100.1F (feels like 102.1F) weather; Winds N 5.1mph; Humidity 10%; ' \
+      "Dew Pt 20.1F; Pressure 1020.1mb; Cloud cover 1%.\n" \
+      'Next hour: minutely weather Next 24h: hourly weather'
+    end
+
+    context 'when given one arg' do
+      it 'should raise error ArgumentError' do
+        expect do
+          LitaForecast::Current.new(forecast).conditions(nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when called with no args' do
+      it { should be_an_instance_of String }
+
+      it { should eql fc_string }
+    end
+  end
+end

data/spec/lita/handlers/forecast/future_spec.rb

@@ -0,0 +1,260 @@
+# -*- coding: UTF-8 -*-
+require 'spec_helper'
+
+describe LitaForecast::Future do
+  let(:forecast) do
+    {
+      'flags' => { 'units' => 'us' },
+      'daily' => {
+        'summary' => 'daily weather',
+        'data' => [
+          {
+            'summary' => 'weather today!',
+            'temperatureMax' => 68.0,
+            'temperatureMin' => 60.2,
+            'precipProbability' => 0,
+            'windSpeed' => 0,
+            'windBearing' => 0
+          },
+          {
+            'summary' => 'weather tomorrow!',
+            'temperatureMax' => 70.0,
+            'temperatureMin' => 62.1,
+            'precipProbability' => 1,
+            'precipType' => 'rain',
+            'windSpeed' => 10,
+            'windBearing' => 270
+          }
+        ]
+      }
+    }
+  end
+
+  before do
+    @future = LitaForecast::Future.new(forecast)
+  end
+
+  describe '#new' do
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          LitaForecast::Future.new(nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          LitaForecast::Future.new
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed a ForecastIO-like response' do
+      subject { LitaForecast::Future.new(forecast) }
+
+      it { should be_an_instance_of LitaForecast::Future }
+
+      it 'should set the ForecastIO-like object to the @f variable' do
+        i = subject.instance_variable_get(:@f)
+        expect(i).to eql forecast
+      end
+    end
+  end
+
+  describe '.daily' do
+    context 'when passed more than zero args' do
+      it 'should raise ArgumentError' do
+        expect do
+          @future.send(:daily, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when called' do
+      subject { @future.send(:daily) }
+
+      it { should be_an_instance_of Array }
+
+      it { should eql forecast['daily']['data'] }
+    end
+  end
+
+  describe '.generate_summary' do
+    context 'when passed more than zero args' do
+      it 'should raise ArgumentError' do
+        expect do
+          @future.send(:generate_summary, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when called' do
+      subject { @future.send(:generate_summary) }
+
+      it { should be_an_instance_of String }
+
+      it { should eql "Summary: daily weather\n" }
+    end
+  end
+
+  describe '.summary' do
+    context 'when given more than zero args' do
+      it 'should raise ArgumentError' do
+        expect do
+          @future.send(:summary, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when called' do
+      before do
+        @future.instance_variable_set(:@i, forecast['daily']['data'][0])
+        @future.instance_variable_set(:@d, 'Today')
+      end
+
+      subject { @future.send(:summary) }
+
+      it { should be_an_instance_of String }
+
+      it { should eql 'Today: weather today!' }
+    end
+  end
+
+  describe '.high_low' do
+    context 'when given more than zero args' do
+      it 'should raise ArgumentError' do
+        expect do
+          @future.send(:high_low, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when called' do
+      before do
+        @future.instance_variable_set(:@i, forecast['daily']['data'][0])
+        @future.instance_variable_set(:@d, 'Today')
+      end
+      let(:good_string) { 'High 68F, Low 60F.' }
+
+      subject { @future.send(:high_low) }
+
+      it { should be_an_instance_of String }
+
+      it { should eql good_string }
+    end
+  end
+
+  describe '.precip' do
+    context 'when given more than zero args' do
+      it 'should raise ArgumentError' do
+        expect do
+          @future.send(:precip, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when called with no preciptType' do
+      before do
+        @future.instance_variable_set(:@i, forecast['daily']['data'][0])
+      end
+
+      subject { @future.send(:precip) }
+
+      it { should be_an_instance_of String }
+
+      it { should eql '0% chance of precipitation.' }
+    end
+
+    context 'when called with a precipType' do
+      before do
+        @future.instance_variable_set(:@i, forecast['daily']['data'][1])
+      end
+
+      subject { @future.send(:precip) }
+
+      it { should be_an_instance_of String }
+
+      it { should eql '100% chance of rain.' }
+    end
+  end
+
+  describe '.wind' do
+    context 'when given more than zero args' do
+      it 'should raise ArgumentError' do
+        expect do
+          @future.send(:wind, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when called' do
+      before do
+        @future.instance_variable_set(:@i, forecast['daily']['data'][0])
+      end
+
+      subject { @future.send(:wind) }
+
+      it { should be_an_instance_of String }
+
+      it { should eql 'Winds N 0mph.' }
+    end
+  end
+
+  describe '.generate_day' do
+    context 'when given more than two args' do
+      it 'should raise ArgumentError' do
+        expect do
+          @future.send(:generate_day, nil, nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than two args' do
+      it 'should raise ArgumentError' do
+        expect do
+          @future.send(:generate_day, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when index is 0 and day is Today' do
+      let(:good_string) do
+        "Today: weather today! High 68F, Low 60F. 0% chance of " \
+        "precipitation. Winds N 0mph.\n"
+      end
+      subject { @future.send(:generate_day, 0, 'Today') }
+
+      it { should be_an_instance_of String }
+
+      it { should eql good_string }
+    end
+  end
+
+  describe '.conditions' do
+    context 'when given more than zero args' do
+      it 'should raise ArgumentError' do
+        expect do
+          @future.conditions(nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when called' do
+      let(:good_string) do
+        "Summary: daily weather\n" \
+        "Today: weather today! High 68F, Low 60F. 0% chance of " \
+        "precipitation. Winds N 0mph.\n" \
+        "Tomorrow: weather tomorrow! High 70F, Low 62F. 100% chance of " \
+        "rain. Winds W 10mph.\n"
+      end
+
+      subject { @future.conditions }
+
+      it { should be_an_instance_of String }
+
+      it { should eql good_string }
+    end
+  end
+end

data/spec/lita/handlers/forecast/location_spec.rb

@@ -0,0 +1,116 @@
+# -*- coding: UTF-8 -*-
+require 'spec_helper'
+require 'hashie'
+
+# Class for stubbing Geolocation data
+#
+class MockGeocoderClass
+  DATA = {
+    'address_components' => [
+      { 'long_name' => 'San Francisco', 'types' => %w(locality) },
+      { 'short_name' => 'CA', 'types' => %w(administrative_area_level_1) }
+    ],
+    'geometry' => {
+      'location' => { 'lat' => 37.7749295, 'lng' => -122.4194155 }
+    }
+  }
+
+  def self.data
+    DATA
+  end
+end
+
+# Class for stubbing Redis class
+#
+class MockRedisClass
+  def self.hgetall(search)
+    Hashie::Mash.new({})
+  end
+end
+
+describe LitaForecast::Location do
+  before do
+    @lfloc = LitaForecast::Location.new(MockRedisClass)
+  end
+
+  describe '#new' do
+    context 'when passed more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          LitaForecast::Location.new(nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed less than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          LitaForecast::Location.new
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed an object' do
+      subject { LitaForecast::Location.new(MockRedisClass) }
+
+      it { should be_an_instance_of LitaForecast::Location }
+    end
+  end
+
+  describe '.lita_redis' do
+    context 'when given an arg' do
+      subject { LitaForecast::Location.new(MockRedisClass).lita_redis }
+
+      it { should eql MockRedisClass }
+    end
+  end
+
+  describe '.find_location' do
+    before do
+      allow_any_instance_of(Geocoder).to receive(:search)
+        .and_return([MockGeocoderClass])
+    end
+
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          @lfloc.find_location(nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less tha one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          @lfloc.find_location
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed "san francisco" and not cached' do
+      let(:good_hash) do
+        { lat: 37.7749295, lng: -122.4194155, desc: 'San Francisco, CA' }
+      end
+
+      subject { @lfloc.find_location('san francisco') }
+
+      it { should be_an_instance_of Hash }
+
+      it { should eql good_hash }
+    end
+
+    context 'when passed "san francisco" and cached' do
+      before do
+        @cr = { lat: 37.7749295, lng: -122.4194155, desc: 'San Francisco, CA' }
+        allow_any_instance_of(MockRedisClass).to receive(:hgetall)
+          .and_return(@cr)
+      end
+
+      subject { @lfloc.find_location('san francisco') }
+
+      it { should be_an_instance_of Hash }
+
+      it { should eql @cr }
+    end
+  end
+end