Merge branch 'validate-user-count-before-issue-date' into 'master'

Validate maximum active user count up until license issue date.

Step 1 of #298

cc @sytse @job

See merge request !402

Gemfile.lock

@@ -219,7 +219,7 @@ GEM
       diff-lcs (~> 1.1)
       mime-types (~> 1.15)
       posix-spawn (~> 0.3)
-    gitlab-license (0.0.2)
+    gitlab-license (0.0.3)
     gitlab-linguist (3.0.1)
       charlock_holmes (~> 0.6.6)
       escape_utils (~> 0.2.4)

app/models/historical_data.rb

@@ -3,6 +3,8 @@ class HistoricalData < ActiveRecord::Base
 
   # HistoricalData.during((Date.today - 1.year)..Date.today).average(:active_user_count)
   scope :during, ->(range) { where(date: range) }
+  # HistoricalData.up_until(Date.today - 1.month).average(:active_user_count)
+  scope :up_until, ->(date) { where("date <= :date", date: date) }
 
   class << self
     def track!

app/models/license.rb

@@ -96,27 +96,23 @@ class License < ActiveRecord::Base
     return unless self.license? && self.restricted?(:active_user_count)
 
     restricted_user_count = self.restrictions[:active_user_count]
-    active_user_count     = User.active.count
-    historical_active_user_count = HistoricalData.maximum(:active_user_count) || 0
 
-    max_active_user_count = [active_user_count, historical_active_user_count].max
+    date_range = (self.starts_at - 1.year)..self.starts_at
+    active_user_count = HistoricalData.during(date_range).maximum(:active_user_count) || 0
+    
+    return unless active_user_count
 
-    return if max_active_user_count < restricted_user_count
+    return if active_user_count < restricted_user_count
 
-    overage = max_active_user_count - restricted_user_count
+    overage = active_user_count - restricted_user_count
 
     message = ""
-    message << 
-      if historical_active_user_count > active_user_count
-        "At one point, this GitLab installation had "
-      else
-        "This GitLab installation has "
-      end
-    message << "#{number_with_delimiter max_active_user_count} active #{"user".pluralize(max_active_user_count)}, "
+    message << "During the year before this license started, this GitLab installation had "
+    message << "#{number_with_delimiter active_user_count} active #{"user".pluralize(active_user_count)}, "
     message << "exceeding this license's limit of #{number_with_delimiter restricted_user_count} by "
     message << "#{number_with_delimiter overage} #{"user".pluralize(overage)}. "
     message << "Please upload a license for at least "
-    message << "#{number_with_delimiter max_active_user_count} #{"user".pluralize(max_active_user_count)}."
+    message << "#{number_with_delimiter active_user_count} #{"user".pluralize(active_user_count)}."
 
     self.errors.add(:base, message)
   end

app/views/admin/licenses/show.html.haml

@@ -20,12 +20,12 @@
       .panel-heading
         Details
       %ul.well-list
-        %li
-          %span.light Issued:
-          %strong= time_ago_with_tooltip @license.issued_at
         %li
           %span.light Uploaded:
           %strong= time_ago_with_tooltip @license.created_at
+        %li
+          %span.light Started:
+          %strong= time_ago_with_tooltip @license.starts_at
         %li
           %span.light 
             - if @license.expired?
@@ -65,7 +65,8 @@
               %strong 
                 Exceeds license limit
 
-        - historical = HistoricalData.maximum(:active_user_count)
+        - date_range = (Date.today - 1.year)..Date.today
+        - historical = HistoricalData.during(date_range).maximum(:active_user_count)
         - if historical 
           %li
             %span.light Maximum active users:
@@ -106,8 +107,8 @@
         %tr
           - @license.licensee.keys.each do |label|
             %th= label
-          %th Issued at
           %th Uploaded at
+          %th Started at
           %th Expired at
           %th Active users
       %tbody
@@ -117,10 +118,10 @@
               %td= license.licensee[label]
             %td
               %span
-                = license.issued_at
+                = license.created_at
             %td
               %span
-                = license.created_at
+                = license.starts_at
             %td
               %span
                 = license.expires_at || "Never"

spec/factories.rb

@@ -211,7 +211,7 @@ FactoryGirl.define do
   end
 
   factory :gitlab_license, class: "Gitlab::License" do
-    issued_at { Date.today - 1.month }
+    starts_at { Date.today - 1.month }
     licensee do 
       { "Name" => Faker::Name.name }
     end

spec/models/historical_data_spec.rb

@@ -8,13 +8,19 @@ describe HistoricalData do
   end
 
   describe ".during" do
-    it "returns the historical data during the given period" do
+    it "returns the historical data during the specified period" do
       expect(HistoricalData.during(Date.new(2014, 1, 1)..Date.new(2014, 12, 31)).average(:active_user_count)).to eq(650)
     end
   end
 
+  describe ".up_until" do
+    it "returns the historical data up until the specified date" do
+      expect(HistoricalData.up_until(Date.new(2014, 6, 1)).average(:active_user_count)).to eq(350)
+    end
+  end
+
   describe ".at" do
-    it "returns the historical data at the given date" do
+    it "returns the historical data at the specified date" do
       expect(HistoricalData.at(Date.new(2014, 8, 1)).active_user_count).to eq(800)
     end
   end

spec/models/license_spec.rb

@@ -23,8 +23,10 @@ describe License do
       end
     end
 
-    describe "Active user count" do
-      let(:active_user_count) { User.active.count }
+    describe "Historical active user count" do
+      let(:active_user_count) { User.active.count + 10 }
+      let(:date)              { License.current.starts_at }
+      let!(:historical_data)  { HistoricalData.create!(date: date, active_user_count: active_user_count) }
 
       context "when there is no active user count restriction" do
         it "is valid" do
@@ -37,39 +39,34 @@ describe License do
           gl_license.restrictions = { active_user_count: active_user_count - 1 }
         end
 
-        it "is invalid" do
-          expect(license).to_not be_valid
+        context "when the license started" do
+          it "is invalid" do
+            expect(license).to_not be_valid
+          end
         end
-      end
 
-      context "when the active user count restriction is not exceeded" do
-        before do
-          gl_license.restrictions = { active_user_count: active_user_count + 1 }
-        end
+        context "after the license started" do
+          let(:date) { Date.today }
 
-        it "is valid" do
-          expect(license).to be_valid
+          it "is valid" do
+            expect(license).to be_valid
+          end
         end
-      end
-    end
 
-    describe "Historical active user count" do
-      let(:active_user_count) { User.active.count + 10 }
-      let!(:historical_data)  { HistoricalData.create!(date: License.current.issued_at, active_user_count: active_user_count) }
+        context "in the year before the license started" do
+          let(:date) { License.current.starts_at - 6.months }
 
-      context "when there is no active user count restriction" do
-        it "is valid" do
-          expect(license).to be_valid
+          it "is invalid" do
+            expect(license).to_not be_valid
+          end
         end
-      end
 
-      context "when the active user count restriction is exceeded" do
-        before do
-          gl_license.restrictions = { active_user_count: active_user_count - 1 }
-        end
+        context "earlier than a year before the license started" do
+          let(:date) { License.current.starts_at - 2.years }
 
-        it "is invalid" do
-          expect(license).to_not be_valid
+          it "is valid" do
+            expect(license).to be_valid
+          end
         end
       end