hubspot-api-ruby 0.8.0

data/lib/hubspot/subscription.rb

@@ -0,0 +1,37 @@
+module Hubspot
+  class Subscription
+    SUBSCRIPTIONS_PATH = '/email/public/v1/subscriptions'
+    TIMELINE_PATH      = '/email/public/v1/subscriptions/timeline'
+    SUBSCRIPTION_PATH  = '/email/public/v1/subscriptions/:email_address'
+
+    attr_reader :subscribed
+    attr_reader :marked_as_spam
+    attr_reader :bounced
+    attr_reader :status
+    attr_reader :subscription_statuses
+
+    def initialize(response_hash)
+      @subscribed     = response_hash['subscribed']
+      @marked_as_spam = response_hash['markedAsSpam']
+      @bounced        = response_hash['bounced']
+      @status         = response_hash['status']
+      @subscription_statuses  = response_hash['SubscriptionStatuses']
+    end
+
+    class << self
+      def status(email)
+        response = Hubspot::Connection.get_json(SUBSCRIPTION_PATH, {email_address: email})
+        new(response)
+      end
+
+      def unsubscribe_from_all_emails(email)
+        response =
+          Hubspot::Connection.put_json(
+            SUBSCRIPTION_PATH, params: { email_address: email },
+                               body: { "unsubscribeFromAll": true }
+          )
+        new(response)
+      end
+    end
+  end
+end

data/lib/hubspot/topic.rb

@@ -0,0 +1,37 @@
+module Hubspot
+  #
+  # HubSpot Topics API
+  #
+  class Topic
+    TOPICS_PATH = "/blogs/v3/topics"
+    TOPIC_PATH = "/blogs/v3/topics/:topic_id"
+
+    class << self
+      # Lists the topics
+      # {https://developers.hubspot.com/docs/methods/blogv2/get_topics)
+      # @return [Hubspot::Topic] array of topics
+      def list
+        response = Hubspot::Connection.get_json(TOPICS_PATH, {})
+        response['objects'].map { |t| new(t) }
+      end
+
+      # Finds the details for a specific topic_id
+      # {https://developers.hubspot.com/docs/methods/blogv2/get_topics_topic_id }
+      # @return Hubspot::Topic
+      def find_by_topic_id(id)
+        response = Hubspot::Connection.get_json(TOPIC_PATH, { topic_id: id })
+        new(response)
+      end
+    end
+
+    attr_reader :properties
+
+    def initialize(response_hash)
+      @properties = response_hash #no need to parse anything, we have properties
+    end
+
+    def [](property)
+      @properties[property]
+    end
+  end
+end

data/lib/hubspot/utils.rb

@@ -0,0 +1,127 @@
+module Hubspot
+  class Utils
+    class << self
+      # Parses the hubspot properties format into a key-value hash
+      def properties_to_hash(props)
+        newprops = HashWithIndifferentAccess.new
+        props.each { |k, v| newprops[k] = v["value"] }
+        newprops
+      end
+
+      # Converts an array of property objects into a hash with the property name
+      # as the key
+      def properties_array_to_hash(props)
+        props.inject({}) { |h, x| h[x["name"]] = x; h }
+      end
+
+      # Turns a hash into the hubspot properties format
+      def hash_to_properties(hash, opts = {})
+        key_name = opts[:key_name] || "property"
+        hash.map { |k, v| { key_name => k.to_s, "value" => v } }
+      end
+
+      def dump_properties(klass, hapikey=ENV['HUBSPOT_API_KEY'], filter={})
+        Hubspot::Deprecator.build.deprecation_warning("Hubspot::Utils.dump_properties")
+
+        with_hapikey(hapikey) do
+          { 'groups'     => klass.groups({}, filter),
+            'properties' => klass.all({}, filter).select { |p| !p['hubspotDefined'] }
+          }
+        end
+      end
+
+      def restore_properties(klass, hapikey=ENV['HUPSPOT_API_KEY'], properties={}, dry_run=false)
+        Hubspot::Deprecator.build.deprecation_warning("Hubspot::Utils.restore_properties")
+
+        existing_properties                       = dump_properties(klass, hapikey)
+        skip, new_groups, new_props, update_props = compare_property_lists(klass, properties, existing_properties)
+        puts '', 'Dry Run - Changes will not be applied' if dry_run
+        puts '','Skipping'
+        skip.each { |h| puts "#{h[:reason]} - #{h[:prop]['groupName']}:#{h[:prop]['name']}" }
+        with_hapikey(hapikey) do
+          create_groups(klass, new_groups, dry_run)
+          create_properties(klass, new_props, dry_run)
+          update_properties(klass, update_props, dry_run)
+        end
+      end
+
+      def create_groups(klass, groups, dry_run=false)
+        puts '','Creating new groups'
+        groups.each do |g|
+          if dry_run || klass.create_group!(g)
+            puts "Created: #{g['name']}"
+          else
+            puts "Failed: #{g['name']}"
+          end
+        end
+      end
+
+      def create_properties(klass, props, dry_run=false)
+        puts '','Creating new properties'
+        props.each do |p|
+          if dry_run || klass.create!(p)
+            puts "Created: #{p['groupName']}:#{p['name']}"
+          else
+            puts "Failed: #{p['groupName']}:#{p['name']}"
+          end
+        end
+      end
+
+      def update_properties(klass, props, dry_run=false)
+        puts '','Updating existing properties'
+        props.each do |p|
+          if dry_run || klass.update!(p['name'], p)
+            puts "Updated: #{p['groupName']}:#{p['name']}"
+          else
+            puts "Failed: #{p['groupName']}:#{p['name']}"
+          end
+        end
+      end
+
+      def compare_property_lists(klass, source, target)
+        skip         = [] # Array of skipped properties and the reason
+        new_groups   = Set.new # Array of groups to create
+        new_props    = [] # Array of properties to add
+        update_props = [] # Array of properties to update
+        src_groups   = source['groups']
+        dst_groups   = target['groups']
+        src_props    = source['properties']
+        dst_props    = target['properties']
+
+        src_props.each do |src|
+          group = find_by_name(src['groupName'], src_groups)
+          if src['createdUserId'].blank? && src['updatedUserId'].blank? then
+            skip << { prop: src, reason: 'Not user created' }
+          else
+            dst = find_by_name(src['name'], dst_props)
+            if dst
+              if dst['readOnlyDefinition']
+                skip << { prop: src, reason: 'Definition is read-only' }
+              elsif klass.same?(src, dst)
+                skip << { prop: src, reason: 'No change' }
+              else
+                new_groups << group unless group.blank? || find_by_name(group['name'], dst_groups)
+                update_props << src
+              end
+            else
+              new_groups << group unless group.blank? || find_by_name(group['name'], dst_groups)
+              new_props << src
+            end
+          end
+        end
+        [skip, new_groups.to_a, new_props, update_props]
+      end
+
+      def with_hapikey(hapikey)
+        Hubspot.configure(hapikey: hapikey)
+        yield if block_given?
+      end
+
+      private
+
+      def find_by_name(name, set)
+        set.detect { |item| item['name'] == name }
+      end
+    end
+  end
+end

data/lib/tasks/hubspot.rake

@@ -0,0 +1,53 @@
+require 'hubspot-api-ruby'
+
+namespace :hubspot do
+  desc 'Dump properties to file'
+  task :dump_properties, [:kind, :file, :hapikey, :include, :exclude] do |_, args|
+    Hubspot::Deprecator.build.deprecation_warning("hubspot:dump_properties")
+
+    hapikey = args[:hapikey] || ENV['HUBSPOT_API_KEY']
+    kind = args[:kind]
+    unless %w(contact deal).include?(kind)
+      raise ArgumentError, ':kind must be either "contact" or "deal"'
+    end
+    klass = kind == 'contact' ? Hubspot::ContactProperties : Hubspot::DealProperties
+    props = Hubspot::Utils::dump_properties(klass, hapikey, build_filter(args))
+    if args[:file].blank?
+      puts JSON.pretty_generate(props)
+    else
+      File.open(args[:file], 'w') do |f|
+        f.write(JSON.pretty_generate(props))
+      end
+    end
+  end
+
+  desc 'Restore properties from file'
+  task :restore_properties, [:kind, :file, :hapikey, :dry_run] do |_, args|
+    Hubspot::Deprecator.build.deprecation_warning("hubspot:restore_properties")
+
+    hapikey = args[:hapikey] || ENV['HUBSPOT_API_KEY']
+    if args[:file].blank?
+      raise ArgumentError, ':file is a required parameter'
+    end
+    kind = args[:kind]
+    unless %w(contact deal).include?(kind)
+      raise ArgumentError, ':kind must be either "contact" or "deal"'
+    end
+    klass = kind == 'contact' ? Hubspot::ContactProperties : Hubspot::DealProperties
+    file = File.read(args[:file])
+    props = JSON.parse(file)
+    Hubspot::Utils.restore_properties(klass, hapikey, props, args[:dry_run] != 'false')
+  end
+
+  private
+
+  def build_filter(args)
+    { include: val_to_array(args[:include]),
+      exclude: val_to_array(args[:exclude])
+    }
+  end
+
+  def val_to_array(val)
+    val.blank? ? val : val.split(/\W+/)
+  end
+end

data/spec/factories/companies.rb

@@ -0,0 +1,9 @@
+
+FactoryBot.define do
+  factory :company, class: Hubspot::Company do
+    to_create { |instance| instance.save }
+
+    add_attribute(:name) { Faker::Company.name }
+    add_attribute(:domain) { Faker::Internet.domain_name }
+  end
+end

data/spec/factories/contacts.rb

@@ -0,0 +1,10 @@
+
+FactoryBot.define do
+  factory :contact, class: Hubspot::Contact do
+    to_create { |instance| instance.save }
+
+    firstname { Faker::Name.first_name }
+    lastname { Faker::Name.last_name }
+    email { Faker::Internet.safe_email("#{Time.new.to_i.to_s[-5..-1]}#{(0..3).map { (65 + rand(26)).chr }.join}") }
+  end
+end

data/spec/lib/hubspot-ruby_spec.rb

@@ -0,0 +1,12 @@
+RSpec.describe Hubspot do
+  describe ".configure" do
+    it "delegates .configure to Hubspot::Config.configure" do
+      options = { hapikey: "demo" }
+      allow(Hubspot::Config).to receive(:configure).with(options)
+
+      Hubspot.configure(options)
+
+      expect(Hubspot::Config).to have_received(:configure).with(options)
+    end
+  end
+end

data/spec/lib/hubspot/blog_spec.rb

@@ -0,0 +1,150 @@
+require 'timecop'
+
+describe Hubspot do
+  before do
+    Hubspot.configure(hapikey: "demo")
+    Timecop.freeze(Time.utc(2012, 'Oct', 10))
+  end
+
+  after do
+    Timecop.return
+  end
+
+  describe Hubspot::Blog do
+    describe ".list" do
+      it "returns a list of blogs" do
+        VCR.use_cassette("blog_list") do
+          result = Hubspot::Blog.list
+
+          assert_requested :get, hubspot_api_url("/content/api/v2/blogs?hapikey=demo")
+          expect(result).to be_kind_of(Array)
+          expect(result.first).to be_a(Hubspot::Blog)
+        end
+      end
+    end
+
+    describe ".find_by_id" do
+      it "retrieves a blog by id" do
+        VCR.use_cassette("blog_list") do
+          id = 351076997
+          result = Hubspot::Blog.find_by_id(id)
+
+          assert_requested :get, hubspot_api_url("/content/api/v2/blogs/#{id}?hapikey=demo")
+          expect(result).to be_a(Hubspot::Blog)
+        end
+      end
+    end
+
+    describe "#[]" do
+      it "returns the value for the given key" do
+        data = {
+          "id" => 123,
+          "name" => "Demo",
+        }
+        blog = Hubspot::Blog.new(data)
+
+        expect(blog["id"]).to eq(data["id"])
+        expect(blog["name"]).to eq(data["name"])
+      end
+
+      context "when the value is unknown" do
+        it "returns nil" do
+          blog = Hubspot::Blog.new({})
+
+          expect(blog["nope"]).to be_nil
+        end
+      end
+    end
+
+    describe "#posts" do
+      it "returns published blog posts created in the last 2 months" do
+        VCR.use_cassette("blog_posts/all_blog_posts") do
+          blog_id = 123
+          created_gt = timestamp_in_milliseconds(Time.now - 2.months)
+          blog = Hubspot::Blog.new({ "id" => blog_id })
+
+          result = blog.posts
+
+          assert_requested :get, hubspot_api_url("/content/api/v2/blog-posts?content_group_id=#{blog_id}&created__gt=#{created_gt}&hapikey=demo&order_by=-created&state=PUBLISHED")
+          expect(result).to be_kind_of(Array)
+        end
+      end
+
+      it "includes given parameters in the request" do
+        VCR.use_cassette("blog_posts/filter_blog_posts") do
+          blog_id = 123
+          created_gt = timestamp_in_milliseconds(Time.now - 2.months)
+          blog = Hubspot::Blog.new({ "id" => 123 })
+
+          result = blog.posts({ state: "DRAFT" })
+
+          assert_requested :get, hubspot_api_url("/content/api/v2/blog-posts?content_group_id=#{blog_id}&created__gt=#{created_gt}&hapikey=demo&order_by=-created&state=DRAFT")
+          expect(result).to be_kind_of(Array)
+        end
+      end
+
+      it "raises when given an unknown state" do
+        blog = Hubspot::Blog.new({})
+
+        expect {
+          blog.posts({ state: "unknown" })
+        }.to raise_error(Hubspot::InvalidParams, "State parameter was invalid")
+      end
+    end
+  end
+
+  describe Hubspot::BlogPost do
+    describe "#created_at" do
+      it "returns the created timestamp as a Time" do
+        timestamp = timestamp_in_milliseconds(Time.now)
+        blog_post = Hubspot::BlogPost.new({ "created" => timestamp })
+
+        expect(blog_post.created_at).to eq(Time.at(timestamp/1000))
+      end
+    end
+
+    describe ".find_by_blog_post_id" do
+      it "retrieves a blog post by id" do
+        VCR.use_cassette "blog_posts" do
+          blog_post_id = 422192866
+
+          result = Hubspot::BlogPost.find_by_blog_post_id(blog_post_id)
+
+          assert_requested :get, hubspot_api_url("/content/api/v2/blog-posts/#{blog_post_id}?hapikey=demo")
+          expect(result).to be_a(Hubspot::BlogPost)
+        end
+      end
+    end
+
+    describe "#topics" do
+      it "returns the list of topics" do
+        VCR.use_cassette "blog_posts" do
+          blog_post = Hubspot::BlogPost.find_by_blog_post_id(422192866)
+
+          topics = blog_post.topics
+
+          expect(topics).to be_kind_of(Array)
+          expect(topics.first).to be_a(Hubspot::Topic)
+        end
+      end
+
+      context "when the blog post does not have topics" do
+        it "returns an empty list" do
+          blog_post = Hubspot::BlogPost.new({ "topic_ids" => [] })
+
+          topics = blog_post.topics
+
+          expect(topics).to be_empty
+        end
+      end
+    end
+  end
+
+  def hubspot_api_url(path)
+    URI.join(Hubspot::Config.base_url, path)
+  end
+
+  def timestamp_in_milliseconds(time)
+    time.to_i * 1000
+  end
+end

data/spec/lib/hubspot/company_properties_spec.rb

@@ -0,0 +1,410 @@
+RSpec.describe Hubspot::CompanyProperties do
+  describe '.add_default_parameters' do
+    let(:opts) { {} }
+    subject { Hubspot::CompanyProperties.add_default_parameters(opts) }
+    context 'default parameters' do
+      context 'without property parameter' do
+        its([:property]) { should == 'email' }
+      end
+
+      context 'with property parameter' do
+        let(:opts) { {property: 'name' } }
+        its([:property]) { should == 'name'}
+      end
+    end
+  end
+
+  before { Hubspot.configure(hapikey: ENV.fetch("HUBSPOT_HAPI_KEY", "demo")) }
+
+  describe ".all" do
+    it "should return all properties" do
+      VCR.use_cassette "company_properties/all_properties" do
+        Hubspot::CompanyProperties.create!({
+          "name" => "fax_number",
+          "label" => "Fax Number",
+          "description" => "The company fax number.",
+          "groupName" => "companyinformation",
+          "type" => "string",
+          "fieldType" => "text"
+        })
+
+        response = Hubspot::CompanyProperties.all
+
+        assert_hubspot_api_request(:get, "/properties/v1/companies/properties")
+
+        company_property_names = response.map { |property| property["name"] }
+        expect(company_property_names).to include("fax_number")
+
+        Hubspot::CompanyProperties.delete!("fax_number")
+      end
+    end
+
+    context "with included groups" do
+      it "should return properties for the specified group[s]" do
+        VCR.use_cassette("company_properties/filter_by_group") do
+          group_a = "socialmediainformation"
+          group_b = "companyinformation"
+
+          Hubspot::CompanyProperties.create!({
+            "name" => "instagram_handle",
+            "label" => "Instagram Handle",
+            "description" => "The company's Instagram handle.",
+            "groupName" => group_a,
+            "type" => "string",
+            "fieldType" => "text"
+          })
+          Hubspot::CompanyProperties.create!({
+            "name" => "fax_number",
+            "label" => "Fax Number",
+            "description" => "The company fax number.",
+            "groupName" => group_b,
+            "type" => "string",
+            "fieldType" => "text"
+          })
+
+          response = Hubspot::CompanyProperties.all({}, { include: [group_a] })
+
+          assert_hubspot_api_request(:get, "/properties/v1/companies/properties")
+
+          group_names = response.map { |property| property["groupName"] }
+          expect(group_names).to include(group_a)
+          expect(group_names).not_to include(group_b)
+
+          Hubspot::CompanyProperties.delete!("instagram_handle")
+          Hubspot::CompanyProperties.delete!("fax_number")
+        end
+      end
+    end
+
+    context "with excluded groups" do
+      it "does not return properties in the exluded groups(s)" do
+        VCR.use_cassette("company_properties/exclude_by_group") do
+          group_a = "socialmediainformation"
+          group_b = "companyinformation"
+
+          Hubspot::CompanyProperties.create!({
+            "name" => "instagram_handle",
+            "label" => "Instagram Handle",
+            "description" => "The company's Instagram handle.",
+            "groupName" => group_a,
+            "type" => "string",
+            "fieldType" => "text"
+          })
+          Hubspot::CompanyProperties.create!({
+            "name" => "fax_number",
+            "label" => "Fax Number",
+            "description" => "The company fax number.",
+            "groupName" => group_b,
+            "type" => "string",
+            "fieldType" => "text"
+          })
+
+          response = Hubspot::CompanyProperties.all({}, { exclude: [group_a] })
+
+          assert_hubspot_api_request(:get, "/properties/v1/companies/properties")
+
+          group_names = response.map { |property| property["groupName"] }
+          expect(group_names).not_to include(group_a)
+          expect(group_names).to include(group_b)
+
+          Hubspot::CompanyProperties.delete!("fax_number")
+          Hubspot::CompanyProperties.delete!("instagram_handle")
+        end
+      end
+    end
+
+    describe ".create!" do
+      it "creates a company property" do
+        VCR.use_cassette("company_properties/create_property") do
+          name = "fax_number"
+
+          create_params = {
+            "name" => name,
+            "groupName" => "companyinformation",
+          }
+
+          response = Hubspot::CompanyProperties.create!(create_params)
+
+          assert_hubspot_api_request(
+            :post,
+            "/properties/v1/companies/properties",
+            body: {
+              name: name,
+              groupName: "companyinformation",
+              options: []
+            }
+          )
+          expect(response["name"]).to eq(name)
+
+          Hubspot::CompanyProperties.delete!(name)
+        end
+      end
+
+      context "with no valid parameters" do
+        it "returns nil" do
+          response = Hubspot::CompanyProperties.create!({})
+
+          expect(response).to be nil
+        end
+      end
+    end
+
+    describe ".update!" do
+      it "updates the company property" do
+        VCR.use_cassette "company_properties/update_property" do
+          name = "fax_number"
+          label = "fax number label"
+          new_label = "new fax number label"
+
+          Hubspot::CompanyProperties.create!({
+            "groupName" => "companyinformation",
+            "label" => label,
+            "name" => name,
+            "type" => "string",
+          })
+
+          update_params = {
+            "groupName" => "companyinformation",
+            "label" => new_label,
+            "type" => "string",
+          }
+
+          response = Hubspot::CompanyProperties.update!(name, update_params)
+
+          assert_hubspot_api_request(
+            :put,
+            "/properties/v1/companies/properties/named",
+            body: {
+              groupName: "companyinformation",
+              label: new_label,
+              options: [],
+              type: "string",
+            }
+          )
+          expect(response["label"]).to eq(new_label)
+
+          Hubspot::CompanyProperties.delete!(name)
+        end
+      end
+
+      context "with no valid parameters" do
+        it "returns nil" do
+          company_property_name = "fax_number"
+          params = {}
+
+          response = Hubspot::CompanyProperties.update!(
+            company_property_name,
+            params
+          )
+
+          expect(response).to be nil
+        end
+      end
+    end
+
+    describe ".delete!" do
+      it "deletes the company property" do
+        VCR.use_cassette("company_properties/delete_property") do
+          name = "fax_number"
+
+          Hubspot::CompanyProperties.create!({
+            "groupName" => "companyinformation",
+            "name" => name,
+            "type" => "string",
+          })
+
+          response = Hubspot::CompanyProperties.delete!(name)
+
+          assert_hubspot_api_request(
+            :delete,
+            "properties/v1/companies/properties/named/#{name}"
+          )
+
+          expect(response).to be nil
+        end
+      end
+
+      context "when the company property does not exist" do
+        it "raises an error" do
+          VCR.use_cassette("company_properties/delete_non_property") do
+            expect {
+              Hubspot::CompanyProperties.delete!("non-existent")
+            }.to raise_error(Hubspot::RequestError)
+          end
+        end
+      end
+    end
+  end
+
+  describe "Groups" do
+    describe ".groups" do
+      it "returns all groups" do
+        VCR.use_cassette("company_properties/all_groups") do
+          group_name = "group_awesome"
+          Hubspot::CompanyProperties.create_group!(name: group_name)
+
+          response = Hubspot::CompanyProperties.groups
+
+          assert_hubspot_api_request(:get, "/properties/v1/companies/groups")
+
+          group_names = response.map { |group| group["name"] }
+          expect(group_names).to include(group_name)
+
+          Hubspot::CompanyProperties.delete_group!(group_name)
+        end
+      end
+
+      context "when included groups are provided" do
+        it "returns the specified groups" do
+          VCR.use_cassette("company_properties/groups_included") do
+            group_a = "socialmediainformation"
+            group_b = "companyinformation"
+
+            Hubspot::CompanyProperties.create!({
+              "name" => "instagram_handle",
+              "label" => "Instagram Handle",
+              "description" => "The company's Instagram handle.",
+              "groupName" => group_a,
+              "type" => "string",
+              "fieldType" => "text"
+            })
+            Hubspot::CompanyProperties.create!({
+              "name" => "fax_number",
+              "label" => "Fax Number",
+              "description" => "The company fax number.",
+              "groupName" => group_b,
+              "type" => "string",
+              "fieldType" => "text"
+            })
+
+            response = Hubspot::CompanyProperties.groups(
+              {},
+              { include: group_a }
+            )
+
+            assert_hubspot_api_request(:get, "/properties/v1/companies/groups")
+
+            Hubspot::CompanyProperties.delete!("instagram_handle")
+            Hubspot::CompanyProperties.delete!("fax_number")
+
+            group_names = response.map { |group| group["name"] }
+            expect(group_names).to include(group_a)
+            expect(group_names).not_to include(group_b)
+          end
+        end
+      end
+
+      context "when excluded groups are provided" do
+        it "returns groups that were not excluded" do
+          VCR.use_cassette("company_properties/groups_excluded") do
+            group_a = "socialmediainformation"
+            group_b = "companyinformation"
+
+            Hubspot::CompanyProperties.create!({
+              "name" => "instagram_handle",
+              "label" => "Instagram Handle",
+              "description" => "The company's Instagram handle.",
+              "groupName" => group_a,
+              "type" => "string",
+              "fieldType" => "text"
+            })
+            Hubspot::CompanyProperties.create!({
+              "name" => "fax_number",
+              "label" => "Fax Number",
+              "description" => "The company fax number.",
+              "groupName" => group_b,
+              "type" => "string",
+              "fieldType" => "text"
+            })
+
+            response = Hubspot::CompanyProperties.groups(
+              {},
+              { exclude: group_a }
+            )
+
+            assert_hubspot_api_request(:get, "/properties/v1/companies/groups")
+
+            group_names = response.map { |group| group["name"] }
+            expect(group_names).not_to include(group_a)
+            expect(group_names).to include(group_b)
+
+            Hubspot::CompanyProperties.delete!("instagram_handle")
+            Hubspot::CompanyProperties.delete!("fax_number")
+          end
+        end
+      end
+    end
+
+    let(:params) { { 'name' => 'ff_group1', 'displayName' => 'Test Group One', 'displayOrder' => 100, 'badParam' => 99 } }
+
+    describe '.create_group!' do
+      context 'with no valid parameters' do
+        it 'should return nil' do
+          expect(Hubspot::CompanyProperties.create_group!({})).to be(nil)
+        end
+      end
+
+      context 'with mixed parameters' do
+        cassette 'company_properties/create_group'
+
+        it 'should return the valid parameters' do
+          response = Hubspot::CompanyProperties.create_group!(params)
+          expect(Hubspot::CompanyProperties.same?(response, params)).to be true
+        end
+      end
+
+      context 'with some valid parameters' do
+        cassette 'company_properties/create_group_some_params'
+
+        let(:sub_params) { params.select { |k, _| k != 'displayName' } }
+
+        it 'should return the valid parameters' do
+          params['name'] = 'ff_group235'
+          response       = Hubspot::CompanyProperties.create_group!(sub_params)
+          expect(Hubspot::CompanyProperties.same?(response, sub_params)).to be true
+        end
+      end
+    end
+
+    describe '.update_group!' do
+      context 'with no valid parameters' do
+
+        it 'should return nil ' do
+          expect(Hubspot::CompanyProperties.update_group!(params['name'], {})).to be(nil)
+        end
+      end
+
+      context 'with mixed parameters' do
+        cassette 'company_properties/update_group'
+
+        it 'should return the valid parameters' do
+          params['displayName'] = 'Test Group OneA'
+
+          response = Hubspot::CompanyProperties.update_group!(params['name'], params)
+          expect(Hubspot::CompanyProperties.same?(response, params)).to be true
+        end
+      end
+
+    end
+
+    describe '.delete_group!' do
+      let(:name) { params['name'] }
+
+      context 'with existing group' do
+        cassette 'company_properties/delete_group'
+
+        it 'should return nil' do
+          expect(Hubspot::CompanyProperties.delete_group!(name)).to eq(nil)
+        end
+      end
+
+      context 'with non-existent group' do
+        cassette 'company_properties/delete_non_group'
+
+        it 'should raise an error' do
+          expect { Hubspot::CompanyProperties.delete_group!(name) }.to raise_error(Hubspot::RequestError)
+        end
+      end
+    end
+  end
+end