lita-forecast 0.1.0

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

@@ -0,0 +1,126 @@
+# -*- coding: UTF-8 -*-
+require 'spec_helper'
+
+describe LitaForecast::Mixins do
+  include LitaForecast::Mixins
+
+  describe '#geo_location' do
+    let(:geocoder) do
+      {
+        'address_components' => [
+          { 'long_name' => 'San Francisco', 'types' => %w(locality) },
+          { 'short_name' => 'CA', 'types' => %w(administrative_area_level_1) }
+        ]
+      }
+    end
+
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect { geo_location(nil, nil) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect { geo_location }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when result is a Geocoder hash' do
+      subject { geo_location(geocoder) }
+
+      it { should be_an_instance_of Hash }
+
+      it 'should set the city to "San Francisco"' do
+        expect(subject[:city]).to eql 'San Francisco'
+      end
+
+      it 'should set the state to CA' do
+        expect(subject[:state]).to eql 'CA'
+      end
+    end
+  end
+
+  describe '#units' do
+    let(:forecast_us) { { 'flags' => { 'units' => 'us' } } }
+    let(:forecast_ca) { { 'flags' => { 'units' => 'ca' } } }
+
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect { units(nil, nil) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect { units }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed a US ForecastIO response' do
+      before do
+        @unit = units(forecast_us)
+      end
+      subject { @unit }
+
+      it { should be_an_instance_of Hash }
+
+      context 'when the temp (:t) key' do
+        subject { @unit[:t] }
+
+        it { should be_an_instance_of String }
+
+        it { should eql 'F' }
+      end
+
+      context 'when the wind (:w) key' do
+        subject { @unit[:w] }
+
+        it { should be_an_instance_of String }
+
+        it { should eql 'mph' }
+      end
+
+      context 'when the visibility (:v) key' do
+        subject { @unit[:v] }
+
+        it { should be_an_instance_of String }
+
+        it { should eql 'mi' }
+      end
+    end
+
+    context 'when passed a CA ForecastIO response' do
+      before do
+        @unit = units(forecast_ca)
+      end
+      subject { @unit }
+
+      it { should be_an_instance_of Hash }
+
+      context 'when the temp (:t) key' do
+        subject { @unit[:t] }
+
+        it { should be_an_instance_of String }
+
+        it { should eql 'C' }
+      end
+
+      context 'when the wind (:w) key' do
+        subject { @unit[:w] }
+
+        it { should be_an_instance_of String }
+
+        it { should eql 'kmph' }
+      end
+
+      context 'when the visibility (:v) key' do
+        subject { @unit[:v] }
+
+        it { should be_an_instance_of String }
+
+        it { should eql 'km' }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# -*- coding: UTF-8 -*-
+require 'spec_helper'
+require 'redis-namespace'
+
+describe LitaForecast do
+  describe '::FORECAST_NAMESPACE' do
+    subject { LitaForecast::FORECAST_NAMESPACE }
+
+    it { should be_an_instance_of String }
+
+    it { should eql 'handlers:forecast' }
+  end
+
+  describe '.redis' do
+    it 'should not take any args' do
+      expect do
+        LitaForecast.redis(nil)
+      end.to raise_error ArgumentError
+    end
+
+    context 'under normal conditions' do
+      subject { LitaForecast.redis }
+
+      it { should be_an_instance_of Redis::Namespace }
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# -*- coding: UTF-8 -*-
+require 'spec_helper'
+
+describe LitaForecast::Response 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
+      },
+      '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
+          }
+        ]
+      },
+      'minutely' => { 'summary' => 'minutely weather' },
+      'hourly' => { 'summary' => 'hourly weather' },
+      'flags' => { 'units' => 'us' }
+    }
+  end
+  let(:location) { 'San Francisco, CA' }
+
+  before do
+    @response = LitaForecast::Response.new(forecast, location)
+  end
+
+  describe '.new' do
+    context 'when given more than two args' do
+      it 'should raise ArgumentError' do
+        expect do
+          LitaForecast::Response.new(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
+          LitaForecast::Response.new(nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given forecast and location' do
+      subject { LitaForecast::Response.new(forecast, location) }
+
+      it { should be_an_instance_of LitaForecast::Response }
+
+      it 'should set the @forecast instance variable' do
+        i = subject.instance_variable_get(:@forecast)
+        expect(i).to eql forecast
+      end
+
+      it 'should set the @location instance variable' do
+        i = subject.instance_variable_get(:@location)
+        expect(i).to eql location
+      end
+    end
+  end
+
+  describe '.generate' do
+    let(:fc_s) do
+      'Now: 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
+    let(:ff_s) 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
+
+    context 'given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          @response.generate(nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when called' do
+      subject { @response.generate }
+
+      it { should be_an_instance_of String }
+
+      it { should eql "San Francisco, CA:\n\n#{fc_s}\n\n#{ff_s}" }
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# -*- coding: UTF-8 -*-
+require 'spec_helper'
+
+# Class for stubbing Redis class
+#
+class MockRedisClass
+  def self.hgetall(search)
+    Hashie::Mash.new({})
+  end
+end
+
+# Class for mocking LitaResponse object
+#
+class MockResponseClass
+  def self.args
+    []
+  end
+end
+
+describe LitaForecast::Weather do
+  include LitaForecast::Weather
+  let(:forecast_h) 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
+      },
+      '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
+          }
+        ]
+      },
+      'minutely' => { 'summary' => 'minutely weather' },
+      'hourly' => { 'summary' => 'hourly weather' },
+      'flags' => { 'units' => 'us' }
+    }
+  end
+  let(:good_string) do
+    "San Francisco, CA:\n\nNow: 100.1F (feels like 102.1F) weather; Winds " \
+    "N 5.1mph; Humidity 10%; Dew Pt 20.1F; Pressure 1020.1mb; Cloud cover " \
+    "1%.\nNext hour: minutely weather Next 24h: hourly weather\n\nSummary: " \
+    "daily weather\nToday: weather today! High 68F, Low 60F. 0% chance of " \
+    "precipitation. Winds N 0mph.\nTomorrow: weather tomorrow! High 70F, " \
+    "Low 62F. 100% chance of rain. Winds W 10mph.\n"
+  end
+
+  describe '#weather_forecast' do
+    context 'when given more than three args' do
+      it 'should raise ArgumentError' do
+        expect do
+          weather_forecast(nil, nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          weather_forecast
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed an API key and location hash' do
+      before do
+        allow(ForecastIO).to receive(:api_key=)
+          .with(any_args).and_return(nil)
+        allow(ForecastIO).to receive(:forecast)
+          .with(any_args).and_return(forecast_h)
+      end
+
+      let(:l_h) do
+        {
+          params: {},
+          lat: 37.7749295,
+          lng: -122.4194155
+        }
+      end
+      subject { weather_forecast('', l_h) }
+
+      it { should be_an_instance_of Hash }
+
+      it { should eql forecast_h }
+    end
+  end
+
+  describe '#weather' do
+    context 'when given more than three args' do
+      it 'should raise ArgumentError' do
+        expect do
+          weather(nil, 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
+          weather(nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given response and api_key' do
+      before do
+        allow(LitaForecast).to receive(:redis).and_return(MockRedisClass)
+        allow(self).to receive(:weather_forecast)
+          .and_return(forecast_h)
+        allow_any_instance_of(LitaForecast::Location)
+          .to receive(:find_location).with(any_args)
+          .and_return(
+            lat: 37.7749295, lng: -122.4194155, desc: 'San Francisco, CA'
+          )
+      end
+
+      subject { weather(MockResponseClass, '') }
+
+      it { should be_an_instance_of String }
+
+      it { should eql good_string }
+    end
+  end
+end

data/spec/lita/handlers/forecast_locations_spec.rb

@@ -0,0 +1,296 @@
+# -*- coding: UTF-8 -*-
+require 'spec_helper'
+
+describe Lita::Handlers::ForecastLocations, lita_handler: true do
+
+  it { routes_command('wadd place 42 42').to(:location_add) }
+
+  it { routes_command('wadd place 42 42 theplace').to(:location_add) }
+
+  it { routes_command('wrm place').to(:location_rm) }
+
+  it { routes_command('wl').to(:locations) }
+
+  describe '.saved_location_hash' do
+    context 'when given a description' do
+      let(:location) { ['home', '42', '42', 'my place'] }
+
+      it 'should return a location hash with unique description' do
+        l = { name: 'home', lat: '42', lng: '42', desc: 'my place' }
+
+        expect(subject.send(:saved_location_hash, location)).to eql l
+      end
+    end
+
+    context 'when not given a description' do
+      let(:location) { %w(home 42 42) }
+
+      it 'should return a location hash with the alias as the desc.' do
+        l = { name: 'home', lat: '42', lng: '42', desc: 'home' }
+
+        expect(subject.send(:saved_location_hash, location)).to eql l
+      end
+    end
+  end
+
+  describe '.rm_from_cache' do
+    context 'when passed more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:rm_from_cache, nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed less than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:rm_from_cache)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed a key, "alias:sf"' do
+      before do
+        allow(LitaForecast.redis).to receive(:del).and_return(nil)
+      end
+      it 'should call LitaForecast.redis.del to delete the key' do
+        key = 'alias:sf'
+        expect(LitaForecast.redis).to receive(:del).with(key).once
+        expect(subject.send(:rm_from_cache, key)).to be_nil
+      end
+    end
+  end
+
+  describe '.add_to_cache' do
+    context 'when passed more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:add_to_cache, nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed less than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:add_to_cache)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed a location' do
+      before do
+        @l_h = { name: 'sf', desc: 'sf', lat: 37.7830503, lng: -122.3933962 }
+        allow(LitaForecast.redis).to receive(:hset).and_return(nil)
+        allow(LitaForecast.redis).to receive(:pipelined).and_yield
+      end
+
+      it 'should add the keys to the cache' do
+        expect(LitaForecast.redis).to receive(:hset)
+          .with('alias:sf', 'lat', 37.7830503).once
+        expect(LitaForecast.redis).to receive(:hset)
+          .with('alias:sf', 'lng', -122.3933962).once
+        expect(LitaForecast.redis).to receive(:hset)
+          .with('alias:sf', 'desc', 'sf').once
+        subject.send(:add_to_cache, @l_h)
+      end
+    end
+  end
+
+  describe '.already_exists?' do
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:alias_exists?, nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:alias_exists?)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when key exists' do
+      before do
+        @h = { desc: 'sf', lat: 37.7830503, lng: -122.3933962 }
+        @key = 'alias:sf'
+        allow(LitaForecast.redis).to receive(:hgetall).with(@key)
+          .and_return(@h)
+      end
+
+      it 'should return true' do
+        expect(subject.send(:alias_exists?, @key)).to be_truthy
+      end
+    end
+
+    context 'when key does not exist' do
+      before do
+        @key = 'alias:toronto' # sorry Canadia
+        allow(LitaForecast.redis).to receive(:hgetall).with(@key)
+          .and_return({})
+      end
+
+      it 'should return true' do
+        expect(subject.send(:alias_exists?, @key)).to be_falsey
+      end
+    end
+  end
+
+  describe '.locations' do
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.locations(nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.locations
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when aliases exist' do
+      before do
+        allow(LitaForecast.redis).to receive(:keys).with('alias:*')
+          .and_return(%w(alias:sf alias:toronto))
+      end
+
+      it 'should return a list of aliases' do
+        send_command('wl')
+        expect(replies.last).to eql 'Known weather aliases: sf, toronto'
+      end
+    end
+
+    context 'when aliases exist' do
+      before do
+        allow(LitaForecast.redis).to receive(:keys).with('alias:*')
+          .and_return([])
+      end
+
+      it 'should return a list of aliases' do
+        send_command('wl')
+        expect(replies.last).to eql 'There are no weather aliases'
+      end
+    end
+  end
+
+  describe '.location_rm' do
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.location_rm(nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.location_rm
+        end
+      end
+    end
+
+    context 'when the alias does not exist' do
+      before do
+        allow_any_instance_of(Lita::Handlers::ForecastLocations)
+          .to receive(:alias_exists?).with('alias:sf').and_return(false)
+      end
+
+      it 'should return that there was no alias' do
+        send_command('wrm sf')
+        expect(replies.last).to eql 'Alias not found'
+      end
+    end
+
+    context 'when the alias exists and is removed' do
+      before do
+        key = 'alias:sf'
+        allow_any_instance_of(Lita::Handlers::ForecastLocations)
+          .to receive(:alias_exists?).with(key).and_return(true)
+        allow_any_instance_of(Lita::Handlers::ForecastLocations)
+          .to receive(:rm_from_cache).with(key).and_return(nil)
+        allow(LitaForecast.redis).to receive(:keys).with(key)
+          .and_return([])
+      end
+
+      it 'should return that there was no alias' do
+        send_command('wrm sf')
+        expect(replies.last).to eql 'Alias removed!'
+      end
+    end
+
+    context 'when the alias exists and fails to remove' do
+      before do
+        key = 'alias:sf'
+        allow_any_instance_of(Lita::Handlers::ForecastLocations)
+          .to receive(:alias_exists?).with(key).and_return(true)
+        allow_any_instance_of(Lita::Handlers::ForecastLocations)
+          .to receive(:rm_from_cache).with(key).and_return(nil)
+        allow(LitaForecast.redis).to receive(:keys).with(key)
+          .and_return(['alias:sf'])
+      end
+
+      it 'should return that there was no alias' do
+        send_command('wrm sf')
+        expect(replies.last).to eql 'Somehow that failed... I need an adult!'
+      end
+    end
+  end
+
+  describe '.location_add' do
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.location_add(nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.location_add
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when the alias already exists' do
+      before do
+        allow_any_instance_of(Lita::Handlers::ForecastLocations)
+          .to receive(:alias_exists?).and_return(true)
+      end
+
+      it 'should return "Already there!"' do
+        send_command('wadd sf 37.7830503 -122.3933962')
+        expect(replies.last).to eql 'Already there!'
+      end
+    end
+
+    context 'when alias does not exist' do
+      before do
+        allow_any_instance_of(Lita::Handlers::ForecastLocations)
+          .to receive(:alias_exists?).and_return(false)
+        allow_any_instance_of(Lita::Handlers::ForecastLocations)
+          .to receive(:saved_location_hash).and_return(nil)
+        allow_any_instance_of(Lita::Handlers::ForecastLocations)
+          .to receive(:add_to_cache).and_return(nil)
+      end
+
+      it 'should return that it was added to the cache' do
+        send_command('wadd sf 37.7830503 -122.3933962')
+        expect(replies.last)
+          .to eql 'sf added to the cache at [37.7830503, -122.3933962]'
+      end
+    end
+  end
+end