evva 0.1.4.3 → 0.4.0

data/lib/evva.rb

@@ -5,8 +5,9 @@ require 'evva/logger'
 require 'evva/google_sheet'
 require 'evva/config'
 require 'evva/file_reader'
-require 'evva/mixpanel_event'
-require 'evva/mixpanel_enum'
+require 'evva/analytics_event'
+require 'evva/analytics_enum'
+require 'evva/analytics_property'
 require 'evva/object_extension'
 require 'evva/version'
 require 'evva/android_generator'
@@ -26,7 +27,7 @@ module Evva
     bundle = analytics_data(config: config.data_source)
     case config.type.downcase
     when 'android'
-      generator = Evva::AndroidGenerator.new
+      generator = Evva::AndroidGenerator.new(config.package_name)
       evva_write(bundle, generator, config, 'kt')
     when 'ios'
       generator = Evva::SwiftGenerator.new
@@ -37,7 +38,7 @@ module Evva
 
   def evva_write(bundle, generator, configuration, extension)
     path = "#{configuration.out_path}/#{configuration.event_file_name}.#{extension}"
-    write_to_file(path, generator.events(bundle[:events], configuration.event_file_name))
+    write_to_file(path, generator.events(bundle[:events], configuration.event_file_name, configuration.event_enum_file_name, configuration.destinations_file_name))
 
     unless configuration.type.downcase == 'ios'
       path = "#{configuration.out_path}/#{configuration.event_enum_file_name}.#{extension}"
@@ -45,22 +46,31 @@ module Evva
     end
 
     path = "#{configuration.out_path}/#{configuration.people_file_name}.#{extension}"
-    write_to_file(path, generator.people_properties(bundle[:people], configuration.people_file_name))
+    write_to_file(path, generator.people_properties(bundle[:people], configuration.people_file_name, configuration.people_enum_file_name, configuration.destinations_file_name))
+
+    unless configuration.type.downcase == 'ios'
+      path = "#{configuration.out_path}/#{configuration.people_enum_file_name}.#{extension}"
+      write_to_file(path, generator.people_properties_enum(bundle[:people], configuration.people_enum_file_name))
+    end
 
     path = "#{configuration.out_path}/#{configuration.special_enum_file_name}.#{extension}"
     write_to_file(path, generator.special_property_enums(bundle[:enums]))
+
+    path = "#{configuration.out_path}/#{configuration.destinations_file_name}.#{extension}"
+    write_to_file(path, generator.destinations(bundle[:destinations], configuration.destinations_file_name))
   end
 
   def analytics_data(config:)
     source =
       case config[:type]
       when 'google_sheet'
-        Evva::GoogleSheet.new(config[:sheet_id])
+        Evva::GoogleSheet.new(config[:events_url], config[:people_properties_url], config[:enum_classes_url])
       end
     events_bundle = {}
     events_bundle[:events] = source.events
     events_bundle[:people] = source.people_properties
     events_bundle[:enums] = source.enum_classes
+    events_bundle[:destinations] = source.destinations
     events_bundle
   end
 

data/spec/evva_spec.rb

@@ -6,12 +6,10 @@ describe Evva do
 
     before do
       allow_any_instance_of(Evva::FileReader).to receive(:open_file).and_return(file)
-      allow_any_instance_of(Evva::GoogleSheet).to receive(:events).and_return(
-        [Evva::MixpanelEvent.new('trackEvent',[])])
-
+      allow_any_instance_of(Evva::GoogleSheet).to receive(:events).and_return([])
       allow_any_instance_of(Evva::GoogleSheet).to receive(:people_properties).and_return([])
       allow_any_instance_of(Evva::GoogleSheet).to receive(:enum_classes).and_return([])
-
+      allow_any_instance_of(Evva::GoogleSheet).to receive(:destinations).and_return([])
       allow(Evva).to receive(:write_to_file)
     end
 
@@ -37,4 +35,4 @@ describe Evva do
                     .and change { Evva::Logger.summary[:error] }.by(1)
     end
   end
-end
+end

data/spec/fixtures/sample_public_enums.csv

@@ -0,0 +1,3 @@
+Enum Name,Possible Values
+PageViewSourceScreen,"course_discovery,synced_courses,nearby,deal"
+PremiumClickBuy,"notes,hi_res_maps,whatever"

data/spec/fixtures/sample_public_events.csv

@@ -0,0 +1,4 @@
+Event Name,Event Properties,Event Destination
+cp_page_view,"course_id:Long,course_name:String","firebase,custom destination"
+nav_feed_tap,,
+cp_view_scorecard,"course_id:Long,course_name:String","custom destination"

data/spec/fixtures/sample_public_people_properties.csv

@@ -0,0 +1,4 @@
+Property Name,Property Type,Property Destination
+rounds_with_wear,String,"firebase,custom destination"
+total_friends,Int,
+wearable_platform,WearableAppPlatform,firebase

data/spec/fixtures/test.yml

@@ -2,9 +2,14 @@ type: Android
 
 data_source:
   type: google_sheet
-  sheet_id: 1LaJd68os3g_GFlerogC64grNIlXb2iukMznOvdml7A4
+  events_url: https://path-to-csv
+  people_properties_url: https://path-to-csv
+  enum_classes_url: https://path-to-csv
 
 out_path: analytics
-event_file_name: MixpanelAnalytics
-event_enum_file_name: MixpanelEvent
-people_file_name: MixpanelProperties
+event_file_name: AnalyticsEvent
+event_enum_file_name: AnalyticsEvents
+people_file_name: AnalyticsProperty
+people_enum_file_name: AnalyticsProperties
+destinations_file_name: AnalyticsDestinations
+package_name: com.package.name.analytics

data/spec/lib/evva/android_generator_spec.rb

@@ -1,75 +1,83 @@
 describe Evva::AndroidGenerator do
-  let(:generator) { described_class.new }
+  let(:generator) { described_class.new("com.hole19golf.hole19.analytics") }
 
   describe '#events' do
-    subject { generator.events(events, "MixpanelAnalytics") }
+    subject { generator.events(events, "AnalyticsEvent", "AnalyticsEvents", "AnalyticsDestinations") }
 
     let(:events) { [
-      Evva::MixpanelEvent.new('cp_page_view'),
-      Evva::MixpanelEvent.new('cp_page_view_a', { course_id: 'Long', course_name: 'String' }),
-      Evva::MixpanelEvent.new('cp_page_view_b', { course_id: 'Long', course_name: 'String', from_screen: 'CourseProfileSource' }),
-      Evva::MixpanelEvent.new('cp_page_view_c', { course_id: 'Long', course_name: 'String', from_screen: 'CourseProfileSource?' }),
-      Evva::MixpanelEvent.new('cp_page_view_d', { course_id: 'Long?', course_name: 'String' })
+      Evva::AnalyticsEvent.new('cp_page_view', {}, []),
+      Evva::AnalyticsEvent.new('cp_page_view_2', {}, ["firebase"]),
+      Evva::AnalyticsEvent.new('cp_page_view_a', { course_id: 'Long', course_name: 'String' }, ["firebase", "custom destination"]),
+      Evva::AnalyticsEvent.new('cp_page_view_b', { course_id: 'Long', course_name: 'String', from_screen: 'CourseProfileSource' }, ["firebase"]),
+      Evva::AnalyticsEvent.new('cp_page_view_c', { course_id: 'Long', course_name: 'String', from_screen: 'CourseProfileSource?' }, []),
+      Evva::AnalyticsEvent.new('cp_page_view_d', { course_id: 'Long?', course_name: 'String' }, []),
     ] }
 
     let(:expected) {
 <<-Kotlin
 package com.hole19golf.hole19.analytics
 
-import com.hole19golf.hole19.analytics.Event
-import com.hole19golf.hole19.analytics.MixpanelAnalyticsMask
-import org.json.JSONObject
-
 /**
  * This file was automatically generated by evva: https://github.com/hole19/evva
  */
 
-open class MixpanelAnalytics(private val mask: MixpanelAnalyticsMask) {
+sealed class AnalyticsEvent(event: AnalyticsEvents) {
+    val name = event.key
 
-    open fun trackCpPageView() {
-        mask.trackEvent(MixpanelEvent.CP_PAGE_VIEW)
-    }
+    open val properties: Map<String, Any?>? = null
+    open val destinations: Array<AnalyticsDestinations> = []
 
-    open fun trackCpPageViewA(course_id: Long, course_name: String) {
-        val properties = JSONObject().apply {
-            put("course_id", course_id)
-            put("course_name", course_name)
-        }
-        mask.trackEvent(MixpanelEvent.CP_PAGE_VIEW_A, properties)
-    }
+    object CpPageView : AnalyticsEvent(AnalyticsEvents.CP_PAGE_VIEW)
 
-    open fun trackCpPageViewB(course_id: Long, course_name: String, from_screen: CourseProfileSource) {
-        val properties = JSONObject().apply {
-            put("course_id", course_id)
-            put("course_name", course_name)
-            put("from_screen", from_screen.key)
-        }
-        mask.trackEvent(MixpanelEvent.CP_PAGE_VIEW_B, properties)
+    data class CpPageView2 : AnalyticsEvent(AnalyticsEvents.CP_PAGE_VIEW_2) {
+        override val destinations = [
+            AnalyticsDestinations.FIREBASE
+        ]
     }
 
-    open fun trackCpPageViewC(course_id: Long, course_name: String, from_screen: CourseProfileSource?) {
-        val properties = JSONObject().apply {
-            put("course_id", course_id)
-            put("course_name", course_name)
-            from_screen?.let { put("from_screen", it.key) }
-        }
-        mask.trackEvent(MixpanelEvent.CP_PAGE_VIEW_C, properties)
+    data class CpPageViewA(
+        val courseId: Long, val courseName: String
+    ) : AnalyticsEvent(AnalyticsEvents.CP_PAGE_VIEW_A) {
+        override val properties = mapOf(
+            "course_id" to courseId,
+            "course_name" to courseName
+        )
+        override val destinations = [
+            AnalyticsDestinations.FIREBASE,
+            AnalyticsDestinations.CUSTOM_DESTINATION
+        ]
     }
 
-    open fun trackCpPageViewD(course_id: Long?, course_name: String) {
-        val properties = JSONObject().apply {
-            course_id?.let { put("course_id", it) }
-            put("course_name", course_name)
-        }
-        mask.trackEvent(MixpanelEvent.CP_PAGE_VIEW_D, properties)
+    data class CpPageViewB(
+        val courseId: Long, val courseName: String, val fromScreen: CourseProfileSource
+    ) : AnalyticsEvent(AnalyticsEvents.CP_PAGE_VIEW_B) {
+        override val properties = mapOf(
+            "course_id" to courseId,
+            "course_name" to courseName,
+            "from_screen" to fromScreen.key
+        )
+        override val destinations = [
+            AnalyticsDestinations.FIREBASE
+        ]
     }
 
-    open fun updateProperties(property: MixpanelProperties, value: Any) {
-        mask.updateProperties(property.key, value)
+    data class CpPageViewC(
+        val courseId: Long, val courseName: String, val fromScreen: CourseProfileSource?
+    ) : AnalyticsEvent(AnalyticsEvents.CP_PAGE_VIEW_C) {
+        override val properties = mapOf(
+            "course_id" to courseId,
+            "course_name" to courseName,
+            "from_screen" to fromScreen?.key
+        )
     }
 
-    open fun incrementCounter(property: MixpanelProperties) {
-        mask.incrementCounter(property.key)
+    data class CpPageViewD(
+        val courseId: Long?, val courseName: String
+    ) : AnalyticsEvent(AnalyticsEvents.CP_PAGE_VIEW_D) {
+        override val properties = mapOf(
+            "course_id" to courseId,
+            "course_name" to courseName
+        )
     }
 }
 Kotlin
@@ -81,8 +89,8 @@ Kotlin
   describe '#special_property_enums' do
     subject { generator.special_property_enums(enums) }
     let(:enums) { [
-      Evva::MixpanelEnum.new('CourseProfileSource', ['course_discovery', 'synced_courses']),
-      Evva::MixpanelEnum.new('PremiumFrom', ['Course Profile', 'Round Setup'])
+      Evva::AnalyticsEnum.new('CourseProfileSource', ['course_discovery', 'synced_courses']),
+      Evva::AnalyticsEnum.new('PremiumFrom', ['Course Profile', 'Round Setup']),
     ] }
     let(:expected) {
 <<-Kotlin
@@ -107,22 +115,20 @@ Kotlin
   end
 
   describe '#event_enum' do
-    subject { generator.event_enum(event_bundle, 'MixpanelEvent') }
+    subject { generator.event_enum(event_bundle, 'AnalyticsEvents') }
     let(:event_bundle) { [
-      Evva::MixpanelEvent.new('nav_feed_tap', {}),
-      Evva::MixpanelEvent.new('nav_performance_tap', {})
+      Evva::AnalyticsEvent.new('nav_feed_tap', {}, []),
+      Evva::AnalyticsEvent.new('nav_performance_tap', {}, []),
       ] }
     let(:expected) {
 <<-Kotlin
 package com.hole19golf.hole19.analytics
 
-import com.hole19golf.hole19.analytics.Event
-
 /**
  * This file was automatically generated by evva: https://github.com/hole19/evva
  */
 
-enum class MixpanelEvent(override val key: String) : Event {
+enum class AnalyticsEvents(val key: String) {
     NAV_FEED_TAP("nav_feed_tap"),
     NAV_PERFORMANCE_TAP("nav_performance_tap");
 }
@@ -132,8 +138,11 @@ Kotlin
   end
 
   describe '#people_properties' do
-    subject { generator.people_properties(people_bundle, 'MixpanelProperties') }
-    let(:people_bundle) { ['rounds_with_wear', 'friends_from_facebook'] }
+    subject { generator.people_properties(people_bundle, 'AnalyticsProperty', 'AnalyticsProperties', 'AnalyticsDestinations') }
+    let(:people_bundle) { [
+      Evva::AnalyticsProperty.new('rounds_with_wear', 'String', []),
+      Evva::AnalyticsProperty.new('wear_platform', 'WearableAppPlatform', ["firebase", "custom destination"]),
+    ] }
     let(:expected) {
 <<-Kotlin
 package com.hole19golf.hole19.analytics
@@ -142,9 +151,74 @@ package com.hole19golf.hole19.analytics
  * This file was automatically generated by evva: https://github.com/hole19/evva
  */
 
-enum class MixpanelProperties(val key: String) {
+sealed class AnalyticsProperty(property: AnalyticsProperties) {
+    val name = property.key
+
+    open val value: Any = ""
+    open val destinations: Array<AnalyticsDestinations> = []
+
+    data class RoundsWithWear(
+        val value: String
+    ) : AnalyticsProperty(AnalyticsProperties.ROUNDS_WITH_WEAR) {
+        override val value = value
+    }
+
+    data class WearPlatform(
+        val value: WearableAppPlatform
+    ) : AnalyticsProperty(AnalyticsProperties.WEAR_PLATFORM) {
+        override val value = value.key
+        override val destinations = [
+            AnalyticsDestinations.FIREBASE,
+            AnalyticsDestinations.CUSTOM_DESTINATION
+        ]
+    }
+}
+Kotlin
+    }
+
+    it { should eq expected }
+  end
+
+  describe '#people_properties_enum' do
+    subject { generator.people_properties_enum(people_bundle, 'AnalyticsProperties') }
+    let(:people_bundle) { [
+      Evva::AnalyticsProperty.new('rounds_with_wear', 'String', ["firebase"]),
+      Evva::AnalyticsProperty.new('wear_platform', 'WearableAppPlatform', ["firebase", "custom destination"]),
+    ] }
+    let(:expected) {
+<<-Kotlin
+package com.hole19golf.hole19.analytics
+
+/**
+ * This file was automatically generated by evva: https://github.com/hole19/evva
+ */
+
+enum class AnalyticsProperties(val key: String) {
     ROUNDS_WITH_WEAR("rounds_with_wear"),
-    FRIENDS_FROM_FACEBOOK("friends_from_facebook");
+    WEAR_PLATFORM("wear_platform");
+}
+Kotlin
+    }
+    it { should eq expected }
+  end
+
+  describe '#destinations' do
+    subject { generator.destinations(destinations_bundle, 'AnalyticsDestinations') }
+    let(:destinations_bundle) { [
+      'firebase',
+      'whatever you want really'
+    ] }
+    let(:expected) {
+<<-Kotlin
+package com.hole19golf.hole19.analytics
+
+/**
+ * This file was automatically generated by evva: https://github.com/hole19/evva
+ */
+
+enum class AnalyticsDestinations {
+    FIREBASE,
+    WHATEVER_YOU_WANT_REALLY;
 }
 Kotlin
     }

data/spec/lib/evva/config_spec.rb

@@ -5,13 +5,18 @@ describe Evva::Config do
     {
       type: 'EvvaOS',
       data_source: {
-        type:         'google_sheet',
-        sheet_id:     'abc1234567890'
+        type: 'google_sheet',
+        events_url: 'https://events.csv',
+        people_properties_url: 'https://people_properties.csv',
+        enum_classes_url: 'https://enum_classes.csv',
       },
       out_path: 'clear/path/to/event',
       event_file_name: 'event/file/name',
+      event_enum_file_name: 'event/enum/file',
       people_file_name: 'people/file/name',
-      event_enum_file_name: 'event/enum/file'
+      people_enum_file_name: 'people/enum/file/name',
+      destinations_file_name: 'destinations/file/name',
+      package_name: 'com.package.name.analytics',
     }
   end
 
@@ -24,13 +29,16 @@ describe Evva::Config do
   its(:type) { should eq('EvvaOS') }
   its(:out_path) { should eq('clear/path/to/event') }
   its(:event_file_name) { should eq('event/file/name') }
-  its(:people_file_name) { should eq('people/file/name') }
   its(:event_enum_file_name) { should eq 'event/enum/file' }
+  its(:people_file_name) { should eq('people/file/name') }
+  its(:people_enum_file_name) { should eq('people/enum/file/name') }
+  its(:destinations_file_name) { should eq 'destinations/file/name' }
+  its(:package_name) { should eq 'com.package.name.analytics' }
 
   describe '#data_source' do
     subject(:data_source) { config.data_source }
 
-    it { should eq(type: 'google_sheet', sheet_id: 'abc1234567890') }
+    it { should eq(type: 'google_sheet', events_url: 'https://events.csv', people_properties_url: 'https://people_properties.csv', enum_classes_url: 'https://enum_classes.csv') }
 
     context 'when given an unknown type data source' do
       before { hash[:data_source] = { type: 'i_dunno' } }

data/spec/lib/evva/google_sheet_spec.rb

@@ -1,107 +1,95 @@
 describe Evva::GoogleSheet do
-  let(:sheet) { Evva::GoogleSheet.new(sheet_id) }
-  let(:sheet_id) { 'abc1234567890' }
-  let(:url_info)  { "https://spreadsheets.google.com/feeds/worksheets/#{sheet_id}/public/full" }
-  let(:url_sheet) { "https://spreadsheets.google.com/feeds/list/#{sheet_id}/od6/public/full" }
-  let(:enum_sheet) { "https://spreadsheets.google.com/feeds/list/#{sheet_id}/osju1vh/public/full" }
-  let(:people_sheet) { "https://spreadsheets.google.com/feeds/list/#{sheet_id}/ojyi830/public/full" }
-  let(:file_info)  { File.read('spec/fixtures/sample_public_info.html') }
-  let(:file_sheet) { File.read('spec/fixtures/sample_public_sheet.html') }
-  let(:enum_file)  { File.read('spec/fixtures/sample_public_enums.html') }
-  let(:people_file)  { File.read('spec/fixtures/sample_public_people_properties.html') }
+  let(:sheet) { Evva::GoogleSheet.new(events_sheet, people_sheet, enum_sheet) }
+
+  let(:events_sheet) { "https://wtvr1" }
+  let(:people_sheet) { "https://wtvr2" }
+  let(:enum_sheet) { "https://wtvr3" }
+  let(:events_file) { File.read('spec/fixtures/sample_public_events.csv') }
+  let(:people_file)  { File.read('spec/fixtures/sample_public_people_properties.csv') }
+  let(:enum_file)  { File.read('spec/fixtures/sample_public_enums.csv') }
+
+  before do
+    stub_request(:get, events_sheet).to_return(status: 200, body: events_file, headers: {})
+    stub_request(:get, people_sheet).to_return(status: 200, body: people_file, headers: {})
+    stub_request(:get, enum_sheet).to_return(status: 200, body: enum_file, headers: {})
+  end
 
   describe '#events' do
     subject(:events) { sheet.events }
-    before do
-      stub_request(:get, url_info).to_return(status: 200, body: file_info, headers: {})
-      stub_request(:get, url_sheet).to_return(status: 200, body: file_sheet, headers: {})
-    end
 
-    context 'when given a valid sheet' do
-      it do
-        expect { events }.not_to raise_error
-      end
+    it do
+      expect { events }.not_to raise_error
+    end
 
-      it 'returns an array with the corresponding events' do
-        expected = [Evva::MixpanelEvent.new('cp_page_view', { course_id: 'Long', course_name: 'String' }),
-                    Evva::MixpanelEvent.new('nav_feed_tap', {}),
-                    Evva::MixpanelEvent.new('cp_view_scorecard', { course_id: 'Long', course_name: 'String' })]
-        expect(events).to eq(expected)
-      end
+    it 'returns an array with the corresponding events' do
+      expected = [
+        Evva::AnalyticsEvent.new('cp_page_view', { course_id: 'Long', course_name: 'String' }, ['firebase', 'custom destination']),
+        Evva::AnalyticsEvent.new('nav_feed_tap', {}, []),
+        Evva::AnalyticsEvent.new('cp_view_scorecard', { course_id: 'Long', course_name: 'String' }, ['custom destination']),
+      ]
+      expect(events).to eq(expected)
     end
 
-    context 'when given an inexistent sheet' do
-      before { stub_request(:get, url_info).to_return(status: 400, body: 'Not Found', headers: {}) }
+    context "when given an inexistent sheet" do
+      before { stub_request(:get, events_sheet).to_return(status: 400, body: "Not Found", headers: {}) }
 
       it do
-        expect { events }.to raise_error /Cannot access sheet/
+        expect { events }.to raise_error /Http Error/
       end
     end
 
-    context 'when given a private sheet' do
-      before { stub_request(:get, url_info).to_return(status: 302, body: '<HTML></HTML>', headers: {}) }
+    context "when url content is not CSV" do
+      before { stub_request(:get, events_sheet).to_return(status: 200, body: "{\"asdsa\": \"This is a json\"}", headers: {}) }
 
       it do
-        expect { events }.to raise_error /Cannot access sheet/
+        expect { events }.to raise_error /Cannot parse. Expected CSV/
       end
     end
+  end
 
-    context 'when url content is not XML' do
-      before { stub_request(:get, url_info).to_return(status: 200, body: 'This is not XML; { this: "is json" }', headers: {}) }
+  describe '#people_properties' do
+    subject(:people_properties) { sheet.people_properties }
 
-      it do
-        expect { events }.to raise_error /Cannot parse. Expected XML/
-      end
+    it do
+      expect { people_properties }.not_to raise_error
     end
-  end
 
-  describe '#enum_classes' do
-    subject(:enum_classes) { sheet.enum_classes }
-    let(:expected_enum) do
-      [
-        Evva::MixpanelEnum.new('PageViewSourceScreen', ['course_discovery','synced_courses','nearby','deal']),
-        Evva::MixpanelEnum.new('PremiumClickBuy', ['notes','hi_res_maps','whatever'])
+    it 'returns an array with the corresponding events' do
+      expect(people_properties).to eq [
+        Evva::AnalyticsProperty.new('rounds_with_wear', 'String', ['firebase', 'custom destination']),
+        Evva::AnalyticsProperty.new('total_friends', 'Int', []),
+        Evva::AnalyticsProperty.new('wearable_platform', 'WearableAppPlatform', ['firebase']),
       ]
     end
+  end
 
-    context 'when given a valid sheet' do
-      before do
-        stub_request(:get, url_info).to_return(status: 200, body: file_info, headers: {})
-        stub_request(:get, enum_sheet).to_return(status: 200, body: enum_file, headers: {})
-      end
-
-      it do
-        expect { enum_classes }.not_to raise_error
-      end
+  describe '#enum_classes' do
+    subject(:enum_classes) { sheet.enum_classes }
 
-      it 'returns an array with the corresponding events' do
-        expect(enum_classes).to eq expected_enum
-      end
+    it do
+      expect { enum_classes }.not_to raise_error
     end
-  end
 
-  describe '#people_properties' do
-    subject(:people_properties) { sheet.people_properties }
-    let(:expected_people_properties) do
-      [
-        'rounds_with_wear',
-        'total_friends'
+    it 'returns an array with the corresponding events' do
+      expect(enum_classes).to eq [
+        Evva::AnalyticsEnum.new('PageViewSourceScreen', ['course_discovery','synced_courses','nearby','deal']),
+        Evva::AnalyticsEnum.new('PremiumClickBuy', ['notes','hi_res_maps','whatever'])
       ]
     end
+  end
 
-    context 'when given a valid sheet' do
-      before do
-        stub_request(:get, url_info).to_return(status: 200, body: file_info, headers: {})
-        stub_request(:get, people_sheet).to_return(status: 200, body: people_file, headers: {})
-      end
+  describe '#destinations' do
+    subject(:destinations) { sheet.destinations }
 
-      it do
-        expect { people_properties }.not_to raise_error
-      end
+    it do
+      expect { destinations }.not_to raise_error
+    end
 
-      it 'returns an array with the corresponding events' do
-        expect(people_properties).to eq expected_people_properties
-      end
+    it 'returns an array with the corresponding events' do
+      expect(destinations).to eq [
+        'firebase',
+        'custom destination',
+      ]
     end
   end
 end