Merge pull request #6 from signaux-faibles/feat-rules-and-cards

traitement des cartes et des règles
signaux-faibles · Oct 7, 2022 · 67314d5 · 67314d5
2 parents f61ff61 + 9a6449f
commit 67314d5
Show file tree

Hide file tree

Showing 26 changed files with 1,782 additions and 538 deletions.
diff --git a/.editorconfig b/.editorconfig
@@ -0,0 +1,13 @@
+# editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.{md,MD}]
+trim_trailing_whitespace = false
diff --git a/.github/workflows/pipeline.yml b/.github/workflows/pipeline.yml
@@ -10,7 +10,6 @@ on:
     types: [published, edited]
   pull_request:
     branches:
-      - 'master'
 
 env:
   GOFLAGS: -mod=readonly
@@ -27,12 +26,15 @@ jobs:
       - name: Set up Go 1.18
         uses: actions/setup-go@v3
         with:
-          go-version: 1.18.x
+          go-version: 1.18
 
       - name: Lint
         uses: golangci/golangci-lint-action@v3
         with:
-          version: v1.49
+          version: v1.45.2
+
+      - name: Run Codacy Analysis CLI
+        uses: codacy/codacy-analysis-cli-action@v4
 
       - name: Unit Tests
         run: go test ./... -v -tags integration

diff --git a/activities.go b/activities.go
@@ -2,6 +2,8 @@ package libwekan
 
 import (
 	"context"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
 	"time"
 )
 
@@ -27,6 +29,15 @@ type Activity struct {
 	ModifiedAt     time.Time    `bson:"modifiedAt"`
 }
 
+func (activityID ActivityID) Check(ctx context.Context, wekan *Wekan) error {
+	_, err := wekan.GetActivityFromID(ctx, activityID)
+	return err
+}
+
+func (activityID ActivityID) GetDocument(ctx context.Context, wekan *Wekan) (Activity, error) {
+	return wekan.GetActivityFromID(ctx, activityID)
+}
+
 func (activity Activity) withIDandDates(t time.Time) (Activity, error) {
 	if activity.ID != "" {
 		return activity, AlreadySetActivityError{}
@@ -137,3 +148,40 @@ func (wekan *Wekan) insertActivity(ctx context.Context, activity Activity) (Acti
 	}
 	return insertable, nil
 }
+
+func (wekan *Wekan) GetActivityFromID(ctx context.Context, activityID ActivityID) (Activity, error) {
+	var activity Activity
+	err := wekan.db.Collection("activities").FindOne(ctx, bson.M{"_id": activityID}).Decode(&activity)
+	if err != nil {
+		if err == mongo.ErrNoDocuments {
+			return Activity{}, UnknownActivityError{string(activityID)}
+		}
+		return Activity{}, UnexpectedMongoError{err}
+	}
+	return activity, nil
+}
+
+func (wekan *Wekan) SelectActivityFromID(ctx context.Context, activityID ActivityID) (Activity, error) {
+	var activity Activity
+	err := wekan.db.Collection("activities").FindOne(ctx, bson.M{"_id": activityID}).Decode(&activity)
+	if err != nil {
+		return Activity{}, UnexpectedMongoError{err}
+	}
+	return activity, nil
+}
+
+func (wekan *Wekan) SelectActivitiesFromQuery(ctx context.Context, query bson.M) ([]Activity, error) {
+	var activities []Activity
+	cur, err := wekan.db.Collection("activities").Find(ctx, query)
+	if err != nil {
+		return nil, UnexpectedMongoError{err}
+	}
+	if err := cur.All(ctx, &activities); err != nil {
+		return nil, UnexpectedMongoError{err}
+	}
+	return activities, nil
+}
+
+func (wekan *Wekan) SelectActivitiesFromBoardID(ctx context.Context, boardID BoardID) ([]Activity, error) {
+	return wekan.SelectActivitiesFromQuery(ctx, bson.M{"boardId": boardID})
+}
diff --git a/activities_integration_test.go b/activities_integration_test.go
@@ -4,7 +4,6 @@
 package libwekan
 
 import (
-	"context"
 	"go.mongodb.org/mongo-driver/bson"
 	"testing"
 
@@ -13,55 +12,121 @@ import (
 
 func TestActivities_insertActivity_whenEverythingsFine(t *testing.T) {
 	ass := assert.New(t)
+	// GIVEN
 	activity := newActivityCreateBoard(UserID(t.Name()+"_userId"), BoardID(t.Name()+"_boardID"))
+
+	// WHEN
 	insertedActivity, err := wekan.insertActivity(ctx, activity)
 	ass.Nil(err)
 
-	selectedActivity, err := wekan.selectActivityFromID(ctx, insertedActivity.ID)
+	// THEN
+	selectedActivity, err := wekan.SelectActivityFromID(ctx, insertedActivity.ID)
 	ass.Nil(err)
 	ass.Equal(insertedActivity, selectedActivity)
 }
 
-func TestActivies_insertActivity_withActivityIsAlreadySet(t *testing.T) {
+func TestActivities_InsertActivity_WithActivityIsAlreadySet(t *testing.T) {
 	ass := assert.New(t)
+	// GIVEN
 	activity := newActivityCreateBoard(UserID(t.Name()+"_userId"), BoardID(t.Name()+"_boardID"))
+
+	// WHEN
 	insertedActivity, err := wekan.insertActivity(ctx, activity)
 	ass.Nil(err)
-
 	notInsertedActivity, err := wekan.insertActivity(ctx, insertedActivity)
-	ass.Empty(notInsertedActivity)
+
+	// THEN
 	ass.IsType(AlreadySetActivityError{}, err)
+	ass.Empty(notInsertedActivity)
 }
 
 func TestActivities_selectActivitiesFromBoardID(t *testing.T) {
 	ass := assert.New(t)
-	board, _ := wekan.GetBoardFromSlug(ctx, "tableau-codefi-nord")
+	// GIVEN
+	board, _, _ := createTestBoard(t, "", 1, 1)
+	userID := UserID(t.Name() + "userID")
+	memberID := UserID(t.Name() + "memberID")
+	activityToInsert := newActivityAddBoardMember(userID, memberID, board.ID)
+	insertedActivity, _ := wekan.insertActivity(ctx, activityToInsert)
 
-	activityToInsert := newActivityAddBoardMember("userID_de_test", "memberId_de_test", board.ID)
+	// WHEN
+	activities, err := wekan.SelectActivitiesFromBoardID(ctx, board.ID)
+
+	// THEN
+	ass.Nil(err)
+	ass.NotNil(activities)
+	ass.Contains(activities, insertedActivity)
+}
+
+func TestActivities_selectActivitiesFromQuery(t *testing.T) {
+	ass := assert.New(t)
+	// GIVEN
+	board, _, _ := createTestBoard(t, "", 1, 1)
+	userID := UserID(t.Name() + "userID")
+	memberID := UserID(t.Name() + "memberID")
+	activityToInsert := newActivityAddBoardMember(userID, memberID, board.ID)
 	insertedActivity, _ := wekan.insertActivity(ctx, activityToInsert)
-	activities, err := wekan.selectActivitiesFromQuery(ctx, bson.M{"boardId": board.ID})
+
+	// WHEN
+	activities, err := wekan.SelectActivitiesFromQuery(ctx, bson.M{"boardId": board.ID})
+
+	// THEN
 	ass.Nil(err)
 	ass.NotNil(activities)
 	ass.Contains(activities, insertedActivity)
 }
 
-func (wekan *Wekan) selectActivityFromID(ctx context.Context, activityID ActivityID) (Activity, error) {
-	var activity Activity
-	err := wekan.db.Collection("activities").FindOne(ctx, bson.M{"_id": activityID}).Decode(&activity)
-	if err != nil {
-		return Activity{}, UnexpectedMongoError{err}
-	}
-	return activity, nil
+func TestActivities_GetActivityFromID(t *testing.T) {
+	ass := assert.New(t)
+	// GIVEN
+	activity := newActivityCreateBoard("", "")
+	insertedActivity, _ := wekan.insertActivity(ctx, activity)
+
+	// WHEN
+	actualActivityFromMethod, err := wekan.GetActivityFromID(ctx, insertedActivity.ID)
+	ass.Nil(err)
+	actualActivityFromID, err := insertedActivity.ID.GetDocument(ctx, &wekan)
+	ass.Nil(err)
+
+	// THEN
+	ass.Equal(insertedActivity, actualActivityFromID)
+	ass.Equal(insertedActivity, actualActivityFromMethod)
+}
+
+func TestActivities_GetActivityFromID_WhenActivityDoesntExist(t *testing.T) {
+	ass := assert.New(t)
+	// GIVEN
+	activityID := ActivityID(t.Name() + "absent")
+
+	// WHEN
+	actualActivityFromMethod, errFromMethod := wekan.GetActivityFromID(ctx, activityID)
+	actualActivityFromID, errFromID := activityID.GetDocument(ctx, &wekan)
+
+	// THEN
+	ass.Empty(actualActivityFromMethod)
+	ass.Empty(actualActivityFromID)
+	ass.IsType(UnknownActivityError{}, errFromMethod)
+	ass.IsType(UnknownActivityError{}, errFromID)
 }
 
-func (wekan *Wekan) selectActivitiesFromQuery(ctx context.Context, query bson.M) ([]Activity, error) {
-	var activities []Activity
-	cur, err := wekan.db.Collection("activities").Find(ctx, query)
-	if err != nil {
-		return nil, UnexpectedMongoError{err}
-	}
-	if err := cur.All(ctx, &activities); err != nil {
-		return nil, UnexpectedMongoError{err}
-	}
-	return activities, nil
+func TestActivities_CheckActivityFromID(t *testing.T) {
+	ass := assert.New(t)
+	// GIVEN
+	activity := newActivityCreateBoard("", "")
+
+	// WHEN
+	insertedActivity, _ := wekan.insertActivity(ctx, activity)
+
+	// THEN
+	ass.Nil(insertedActivity.ID.Check(ctx, &wekan))
+
+}
+
+func TestActivities_CheckActivityFromID_WhenActivityDoesntExist(t *testing.T) {
+	ass := assert.New(t)
+	// GIVEN
+	activityID := ActivityID(t.Name() + "absent")
+
+	// THEN
+	ass.IsType(UnknownActivityError{}, activityID.Check(ctx, &wekan))
 }