From 18c490832118139d0811798c91fa554b7ac9a7a7 Mon Sep 17 00:00:00 2001
From: Yoshiyuki Mineo <yoshiyuki.mineo@sony.com>
Date: Sun, 13 Aug 2023 22:53:30 +0900
Subject: [PATCH 1/3] Update go versions

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index cb5013f..c281d82 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -4,7 +4,7 @@ jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.19.x, 1.20.x]
+        go-version: [1.20.x, 1.21.x]
         os: [ubuntu-latest]
     runs-on: ${{matrix.os}}
     steps:

From 06f9b47996ac97eb466742954006435df461ffc2 Mon Sep 17 00:00:00 2001
From: Yoshiyuki Mineo <Yoshiyuki.Mineo@jp.sony.com>
Date: Mon, 14 Aug 2023 01:27:55 +0900
Subject: [PATCH 2/3] Introduce New function (#47)

* feat(Sonyflake): define error variables

* feat(Sonyflake): add New() function
- minor logic improvements
- return errors

* tests(Sonyflake): remove old TestNilSonyflake test function in favour of the New() function coverage

* gofmt

* Update error messages and comments

* Introduce New function

---------

Co-authored-by: Quetzy Garcia <quetzy.garcia@integrate.com>
---
 README.md         |  4 +--
 sonyflake.go      | 42 +++++++++++++++++++------
 sonyflake_test.go | 79 +++++++++++++++++++++++++++++++++--------------
 3 files changed, 89 insertions(+), 36 deletions(-)

diff --git a/README.md b/README.md
index 9c9ebeb..0e6cdab 100644
--- a/README.md
+++ b/README.md
@@ -33,10 +33,10 @@ go get github.com/sony/sonyflake
 Usage
 -----
 
-The function NewSonyflake creates a new Sonyflake instance.
+The function New creates a new Sonyflake instance.
 
 ```go
-func NewSonyflake(st Settings) *Sonyflake
+func New(st Settings) (*Sonyflake, error)
 ```
 
 You can configure Sonyflake by the struct Settings:
diff --git a/sonyflake.go b/sonyflake.go
index 1c1402e..548b243 100644
--- a/sonyflake.go
+++ b/sonyflake.go
@@ -52,21 +52,29 @@ type Sonyflake struct {
 	machineID   uint16
 }
 
+var (
+	ErrStartTimeAhead   = errors.New("start time is ahead of now")
+	ErrNoPrivateAddress = errors.New("no private ip address")
+	ErrOverTimeLimit    = errors.New("over the time limit")
+	ErrInvalidMachineID = errors.New("invalid machine id")
+)
+
 var defaultInterfaceAddrs = net.InterfaceAddrs
 
-// NewSonyflake returns a new Sonyflake configured with the given Settings.
-// NewSonyflake returns nil in the following cases:
+// New returns a new Sonyflake configured with the given Settings.
+// New returns an error in the following cases:
 // - Settings.StartTime is ahead of the current time.
 // - Settings.MachineID returns an error.
 // - Settings.CheckMachineID returns false.
-func NewSonyflake(st Settings) *Sonyflake {
+func New(st Settings) (*Sonyflake, error) {
+	if st.StartTime.After(time.Now()) {
+		return nil, ErrStartTimeAhead
+	}
+
 	sf := new(Sonyflake)
 	sf.mutex = new(sync.Mutex)
 	sf.sequence = uint16(1<<BitLenSequence - 1)
 
-	if st.StartTime.After(time.Now()) {
-		return nil
-	}
 	if st.StartTime.IsZero() {
 		sf.startTime = toSonyflakeTime(time.Date(2014, 9, 1, 0, 0, 0, 0, time.UTC))
 	} else {
@@ -79,10 +87,24 @@ func NewSonyflake(st Settings) *Sonyflake {
 	} else {
 		sf.machineID, err = st.MachineID()
 	}
-	if err != nil || (st.CheckMachineID != nil && !st.CheckMachineID(sf.machineID)) {
-		return nil
+	if err != nil {
+		return nil, err
 	}
 
+	if st.CheckMachineID != nil && !st.CheckMachineID(sf.machineID) {
+		return nil, ErrInvalidMachineID
+	}
+
+	return sf, nil
+}
+
+// NewSonyflake returns a new Sonyflake configured with the given Settings.
+// NewSonyflake returns nil in the following cases:
+// - Settings.StartTime is ahead of the current time.
+// - Settings.MachineID returns an error.
+// - Settings.CheckMachineID returns false.
+func NewSonyflake(st Settings) *Sonyflake {
+	sf, _ := New(st)
 	return sf
 }
 
@@ -127,7 +149,7 @@ func sleepTime(overtime int64) time.Duration {
 
 func (sf *Sonyflake) toID() (uint64, error) {
 	if sf.elapsedTime >= 1<<BitLenTime {
-		return 0, errors.New("over the time limit")
+		return 0, ErrOverTimeLimit
 	}
 
 	return uint64(sf.elapsedTime)<<(BitLenSequence+BitLenMachineID) |
@@ -152,7 +174,7 @@ func privateIPv4(interfaceAddrs types.InterfaceAddrs) (net.IP, error) {
 			return ip, nil
 		}
 	}
-	return nil, errors.New("no private ip address")
+	return nil, ErrNoPrivateAddress
 }
 
 func isPrivateIPv4(ip net.IP) bool {
diff --git a/sonyflake_test.go b/sonyflake_test.go
index db58778..0a7aa4f 100644
--- a/sonyflake_test.go
+++ b/sonyflake_test.go
@@ -2,6 +2,7 @@ package sonyflake
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"net"
 	"runtime"
@@ -40,6 +41,60 @@ func nextID(t *testing.T) uint64 {
 	return id
 }
 
+func TestNew(t *testing.T) {
+	genError := fmt.Errorf("an error occurred while generating ID")
+
+	tests := []struct {
+		name     string
+		settings Settings
+		err      error
+	}{
+		{
+			name: "failure: time ahead",
+			settings: Settings{
+				StartTime: time.Now().Add(time.Minute),
+			},
+			err: ErrStartTimeAhead,
+		},
+		{
+			name: "failure: machine ID",
+			settings: Settings{
+				MachineID: func() (uint16, error) {
+					return 0, genError
+				},
+			},
+			err: genError,
+		},
+		{
+			name: "failure: invalid machine ID",
+			settings: Settings{
+				CheckMachineID: func(uint16) bool {
+					return false
+				},
+			},
+			err: ErrInvalidMachineID,
+		},
+		{
+			name:     "success",
+			settings: Settings{},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			sonyflake, err := New(test.settings)
+
+			if !errors.Is(err, test.err) {
+				t.Fatalf("unexpected value, want %#v, got %#v", test.err, err)
+			}
+
+			if sonyflake == nil && err == nil {
+				t.Fatal("unexpected value, sonyflake should not be nil")
+			}
+		})
+	}
+}
+
 func TestSonyflakeOnce(t *testing.T) {
 	sleepTime := time.Duration(50 * sonyflakeTimeUnit)
 	time.Sleep(sleepTime)
@@ -150,30 +205,6 @@ func TestSonyflakeInParallel(t *testing.T) {
 	fmt.Println("number of id:", len(set))
 }
 
-func TestNilSonyflake(t *testing.T) {
-	var startInFuture Settings
-	startInFuture.StartTime = time.Now().Add(time.Duration(1) * time.Minute)
-	if NewSonyflake(startInFuture) != nil {
-		t.Errorf("sonyflake starting in the future")
-	}
-
-	var noMachineID Settings
-	noMachineID.MachineID = func() (uint16, error) {
-		return 0, fmt.Errorf("no machine id")
-	}
-	if NewSonyflake(noMachineID) != nil {
-		t.Errorf("sonyflake with no machine id")
-	}
-
-	var invalidMachineID Settings
-	invalidMachineID.CheckMachineID = func(uint16) bool {
-		return false
-	}
-	if NewSonyflake(invalidMachineID) != nil {
-		t.Errorf("sonyflake with invalid machine id")
-	}
-}
-
 func pseudoSleep(period time.Duration) {
 	sf.startTime -= int64(period) / sonyflakeTimeUnit
 }

From fc2f84a086d25d207a91768bc47edfb84972fef5 Mon Sep 17 00:00:00 2001
From: "David E. Wheeler" <46604+theory@users.noreply.github.com>
Date: Mon, 6 Nov 2023 00:32:46 -0500
Subject: [PATCH 3/3] Use net.IP.Equal instead of bytes.Equal (#49)

As suggested by go-staticcheck.
---
 sonyflake_test.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/sonyflake_test.go b/sonyflake_test.go
index 0a7aa4f..98f8552 100644
--- a/sonyflake_test.go
+++ b/sonyflake_test.go
@@ -1,7 +1,6 @@
 package sonyflake
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
 	"net"
@@ -259,7 +258,7 @@ func TestPrivateIPv4(t *testing.T) {
 				return
 			}
 
-			if bytes.Equal(actual, tc.expected) {
+			if net.IP.Equal(actual, tc.expected) {
 				return
 			} else {
 				t.Errorf("error: expected: %s, but got: %s", tc.expected, actual)