diff --git a/dist/index.html b/dist/index.html
index 4586ff721..66a35ebe6 100644
--- a/dist/index.html
+++ b/dist/index.html
@@ -90,7 +90,7 @@ <h3>Account Details</h3>
           <span><p>Stride Length:</p><h3 id="account-stride">stride length</h3></span>
           <span><p>Daily Step Goal:</p><h3 id="account-step">daily step goal</h3></span>
           <span><p>Friends:</p><h3 id="account-friends">friends</h3></span>
-  <!-- Update HTML in Account Details section to be dynamic with UpdateAccount refactor -->
+<!-- Update HTML in Account Details section to be dynamic with UpdateAccount refactor -->
           <!-- <span><p>User:</p><h3 id="name">name</h3></span>
           <span><p>Address:</p><h3 id="address">address</h3></span>
           <span><p>Email:</p><h3 id="email">email</h3></span>
diff --git a/src/domUpdates.js b/src/domUpdates.js
index d90abda43..7a2d4dc31 100644
--- a/src/domUpdates.js
+++ b/src/domUpdates.js
@@ -117,7 +117,7 @@ function updateAccountFriends(friends) {
   accountFriends.textContent = `${friends}`;
 }
 
-        // refactor updateAccountFriends() + updateAccountStep() + updateAccountStride()
+        // refactor updateAccountFriends() + updateAccountStep() + updateAccountStride() 
         // + updateAccountName() + updateAccountEmail() + updateAccountAddress()
         function updateAccountData(user) {
           Object.keys(user).forEach(dataType => {
diff --git a/src/hydration.js b/src/hydration.js
new file mode 100644
index 000000000..df75afdf4
--- /dev/null
+++ b/src/hydration.js
@@ -0,0 +1,28 @@
+import hydration from '../src/data/hydration-test-data'
+
+function getAverageDailyFluidOunces(userId, hydroData) {
+    const userHydrationData = hydroData.filter((userRecord) => userRecord.userID === userId);
+    const totalOunces = userHydrationData.reduce((acc, userRecord) => acc += userRecord.numOunces, 0);
+    return userHydrationData.length > 0 ? totalOunces / userHydrationData.length : 0;
+}
+
+function getSpecificDay(userId, date, hydroData) {
+const dayEntry = hydroData.find(entry => entry.userID === userId && entry.date === date);
+return dayEntry ? dayEntry.numOunces : 0; 
+}
+
+function getWeeklyFluidOunces(userId) {
+const userHydrationData = hydration.hydrationData.filter(record => record.userID === userId);
+userHydrationData.sort((a, b) => new Date(b.date) - new Date(a.date));
+const lastWeekData = userHydrationData.slice(0, 7);
+return lastWeekData.map(record => ({
+    date: record.date,
+    numOunces: record.numOunces
+}));
+}
+
+export {
+    getAverageDailyFluidOunces,
+    getSpecificDay,
+    getWeeklyFluidOunces,
+};
\ No newline at end of file
diff --git a/src/scripts.js b/src/scripts.js
index fa05d5ade..108d11103 100644
--- a/src/scripts.js
+++ b/src/scripts.js
@@ -89,6 +89,7 @@ function getWeeklyFluidOunces(userId) {
 function getUserSleepData(randomUser) {
   return appState.sleep.sleepData.filter(user => user.userID === randomUser.id)
 }
+
 function getAverageSleepHours(randomUser) {
   let sameUserSleepData = getUserSleepData(randomUser)
   let averageSleepHours = 0
@@ -137,6 +138,7 @@ function getMostRecentSleepQuality(randomUser) {
 
         // refactored getMostRecentSleepHours() + getMostRecentSleepQuality()
         function getMostRecentSleepData(randomUser, sleepDataType) {
+
           let sameUserSleepData = getUserSleepData(randomUser)
           let latestSleepDataIndex = sameUserSleepData.length - 1
           return sameUserSleepData[latestSleepDataIndex][sleepDataType]
diff --git a/src/sleep.js b/src/sleep.js
new file mode 100644
index 000000000..8379963f9
--- /dev/null
+++ b/src/sleep.js
@@ -0,0 +1,57 @@
+import sleep from '../src/data/sleep-test-data'
+
+function getUserSleepData(randomUser) {
+    return sleep.sleepData.filter(user => user.userID === randomUser.id)
+}
+
+function getAverageSleepHours(randomUser) {
+let sameUserSleepData = getUserSleepData(randomUser)
+let averageSleepHours = 0
+let totalSleepHours = 0
+sameUserSleepData.forEach(obj => {
+    totalSleepHours += obj.hoursSlept
+})
+averageSleepHours = totalSleepHours / sameUserSleepData.length
+return averageSleepHours.toFixed(2)
+}
+
+function getAverageSleepQuality(randomUser) {
+let sameUserSleepData = getUserSleepData(randomUser)
+let averageSleepQuality = 0
+let totalSleepQuality = 0
+sameUserSleepData.forEach(obj => {
+    totalSleepQuality += obj.sleepQuality
+})
+averageSleepQuality = totalSleepQuality / sameUserSleepData.length
+return averageSleepQuality.toFixed(2)
+}
+
+function getMostRecentSleepHours(randomUser) {
+let sameUserSleepData = getUserSleepData(randomUser)
+let latestSleepDataIndex = sameUserSleepData.length - 1
+return sameUserSleepData[latestSleepDataIndex].hoursSlept
+}
+
+function getMostRecentSleepQuality(randomUser) {
+let sameUserSleepData = getUserSleepData(randomUser)
+let latestSleepDataIndex = sameUserSleepData.length - 1
+return sameUserSleepData[latestSleepDataIndex].sleepQuality
+}
+
+function getWeeklySleepHours(selectedWeek) {
+return selectedWeek[0].map(day => day.hoursSlept)
+}
+
+function getWeeklySleepQuality(selectedWeek) {
+return selectedWeek[0].map(day => day.sleepQuality)
+}
+
+export {
+    getUserSleepData,
+    getAverageSleepHours,
+    getAverageSleepQuality,
+    getMostRecentSleepHours,
+    getMostRecentSleepQuality,
+    getWeeklySleepHours,
+    getWeeklySleepQuality
+};
\ No newline at end of file
diff --git a/src/users.js b/src/users.js
index fa9798069..2a1ecb22f 100644
--- a/src/users.js
+++ b/src/users.js
@@ -1,5 +1,7 @@
 import account from '../src/data/users-test-data'
 
+// ----- * Users * ----- //
+
 function generateRandomUser() {
     const randomIndex = Math.floor(Math.random() * account.users.length);
     return account.users[randomIndex];
@@ -16,7 +18,13 @@ function getAccountFriends(user) {
     return friendNames.join(" - ")
 }
 
+function getAverageStepGoal(account) {
+    const totalStepsGoal = account.users.reduce((total, user) => total + user.dailyStepGoal, 0);
+    return totalStepsGoal / account.users.length;
+    }
+
+
 export {
     generateRandomUser,
     getAccountFriends,
-};
\ No newline at end of file
+    getAverageStepGoal,
diff --git a/test/hydration-test.js b/test/hydration-test.js
new file mode 100644
index 000000000..ce49021c8
--- /dev/null
+++ b/test/hydration-test.js
@@ -0,0 +1,108 @@
+import { expect } from 'chai';
+import { 
+    generateRandomUser, 
+    getAverageDailyFluidOunces,
+    getSpecificDay,
+    getWeeklyFluidOunces,
+} from '../src/hydration';
+import account from '../src/data/users-test-data'
+import hydration from '../src/data/hydration-test-data'
+
+describe('getAverageDailyFluidOunces()', () => {
+    
+    const account = [
+        { userID: 1, numOunces: 64 },
+        { userID: 1, numOunces: 80 },
+        { userID: 2, numOunces: 72 }, 
+        { userID: 1, numOunces: 96 },
+      ];
+    
+    it('calculates the correct average for multiple records', () => {
+    expect(getAverageDailyFluidOunces(1, account)).to.equal((64 + 80 + 96) / 3);
+    });
+
+    it('returns 0 for a user with no records', () => {
+        expect(getAverageDailyFluidOunces(3, account)).to.equal(0);
+    });
+
+    it('returns the correct value for a single record', () => {
+        const singleRecordAccount = [{ userID: 1, numOunces: 64 }];
+        expect(getAverageDailyFluidOunces(1, singleRecordAccount)).to.equal(64);
+    });
+
+    it('filters records correctly among multiple users', () => {
+        expect(getAverageDailyFluidOunces(2, account)).to.equal(72);
+    });
+
+});
+
+describe('getSpecificDay()', () => {
+    
+    const hydroData = [
+        { userID: 1, date: '2022-04-01', numOunces: 64 },
+        { userID: 1, date: '2022-04-02', numOunces: 80 },
+        { userID: 2, date: '2022-04-01', numOunces: 72 },
+        { userID: 1, date: '2022-04-03', numOunces: 96 },
+    ];
+    
+    it('returns the correct numOunces for a user on a specific date', () => {
+    const ounces = getSpecificDay(1, '2022-04-02', hydroData);
+    expect(ounces).to.equal(80);
+    });
+
+    it('returns 0 if no entry is found for the user on the specified date', () => {
+        const ounces = getSpecificDay(1, '2022-04-04', hydroData); 
+        expect(ounces).to.equal(0);
+    });
+    
+    it('returns 0 if the user ID does not exist in the data', () => {
+    const ounces = getSpecificDay(3, '2022-04-01', hydroData); 
+    expect(ounces).to.equal(0);
+    });
+
+    it('handles searching for a date with multiple users\' data correctly', () => {
+    const ounces = getSpecificDay(2, '2022-04-01', hydroData);
+    expect(ounces).to.equal(72);
+    });
+
+    it('returns 0 for invalid userId types', () => {
+    const ounces = getSpecificDay(null, '2022-04-02', hydroData);
+    expect(ounces).to.equal(0);
+    });
+
+    it('returns 0 for invalid date formats', () => {
+    const ounces = getSpecificDay(1, 'not-a-date', hydroData);
+    expect(ounces).to.equal(0);
+    });
+
+    it('returns 0 when hydroData is empty', () => {
+    const ounces = getSpecificDay(1, '2022-04-02', []);
+    expect(ounces).to.equal(0);
+    });
+
+});
+
+describe('getWeeklyFluidOunces()', () => {
+
+    let randomUser = generateRandomUser()
+
+    it('returns the last week data for a user', function() {
+        const result = getWeeklyFluidOunces(2);
+        expect(result.length).to.equal(7); 
+        expect(result[0].numOunces).to.equal(78); 
+        expect(result[4].numOunces).to.equal(70);
+      });
+    
+      it('returns the last week data for a different user', function() {
+        const result = getWeeklyFluidOunces(9);
+        expect(result.length).to.equal(7); 
+        expect(result[0].numOunces).to.equal(86); 
+        expect(result[6].numOunces).to.equal(74);
+      });
+
+      it('returns an empty array for users with no data', function() {
+        const result = getWeeklyFluidOunces(999); 
+        expect(result).to.be.an('array').that.is.empty;
+      });
+
+});
\ No newline at end of file
diff --git a/test/sleep-test.js b/test/sleep-test.js
new file mode 100644
index 000000000..384f46b92
--- /dev/null
+++ b/test/sleep-test.js
@@ -0,0 +1,205 @@
+import { expect } from 'chai';
+import { 
+    generateRandomUser, 
+    getUserSleepData,
+    getAverageSleepHours,
+    getAverageSleepQuality,
+    getMostRecentSleepHours,
+    getMostRecentSleepQuality,
+    getWeeklySleepHours,
+    getWeeklySleepQuality
+
+} from '../src/functions';
+import account from '../src/data/users-test-data'
+import sleep from '../src/data/sleep-test-data'
+
+describe('getUserSleepData()', () => {
+    
+    let randomUser = generateRandomUser()
+    
+    it('should return an empty array for a user with no sleep data', function() {
+        const nonExistentUser = { id: 999 };
+        const result = getUserSleepData(nonExistentUser);
+        expect(result).to.be.an('array').that.is.empty;
+    });
+
+    it('should return all sleep data entries for a given user', function() {
+        const result = getUserSleepData(randomUser);
+        expect(result).to.be.an('array');
+        expect(result).to.have.lengthOf.at.least(10); 
+        result.forEach(data => {
+            expect(data.userID).to.equal(randomUser.id);
+        });
+    });
+
+});
+
+describe('getAverageSleepHours()', () => {
+
+    it('should calculate the correct average sleep hours for a given user', function() {
+        const user1 = account.users[1]
+        const averageSleepHours = getAverageSleepHours(user1);
+        expect(averageSleepHours).to.be.a('string');
+        const expectedAverage = (7.94).toFixed(2);
+        expect(averageSleepHours).to.equal(expectedAverage);
+    });
+    
+    it('should calculate the correct average sleep hours for a different user', function() {
+        const user2 = account.users[7]
+        const averageSleepHours = getAverageSleepHours(user2);
+        const expectedAverage = (8.67).toFixed(2); 
+        expect(averageSleepHours).to.equal(expectedAverage);
+    });
+
+    it('should handle cases with no sleep data for a given user', function() {
+        const randomUser = { id: 999 }; 
+        const averageSleepHours = getAverageSleepHours(randomUser);
+        expect(averageSleepHours).to.equal('NaN');
+        
+    });
+
+});
+
+describe('getAverageSleepQuality()', () => {
+
+    it('should calculate the correct average sleep quality for a given user', function() {
+        const userP = account.users[1]
+        const averageSleepQuality = getAverageSleepQuality(userP);
+        expect(averageSleepQuality).to.be.a('string');
+        const expectedAverage = (3.61).toFixed(2);
+        expect(averageSleepQuality).to.equal(expectedAverage);
+    });
+    
+    it('should calculate the correct average sleep quality for a different user', function() {
+        const userY = account.users[5]
+        const averageSleepQuality = getAverageSleepQuality(userY);
+        expect(averageSleepQuality).to.be.a('string');
+        const expectedAverage = (3.29).toFixed(2);
+        expect(averageSleepQuality).to.equal(expectedAverage);
+    });
+
+    it('should return "NaN" for a user with no sleep data', function() {
+        const nonExistentUser = { id: 999 };
+        const averageSleepQuality = getAverageSleepQuality(nonExistentUser);
+        expect(averageSleepQuality).to.equal('NaN');
+    });
+
+});
+
+describe('getMostRecentSleepHours()', () => {
+
+    it('should return the most recent sleep data entry for a user', function() {
+        const user444 = account.users[5];
+        const mostRecentSleepHours = getMostRecentSleepHours(user444);
+        expect(mostRecentSleepHours).to.be.a('number');
+        const expectedAverage = (7.3)
+        expect(mostRecentSleepHours).to.equal(expectedAverage);
+    });
+    
+    it('should return the most recent sleep data entry for a different user', function() {
+        const user000 = account.users[9];
+        const mostRecentSleepHours = getMostRecentSleepHours(user000);
+        const expectedAverage = (9.7)
+        expect(mostRecentSleepHours).to.equal(expectedAverage);
+    });
+
+
+    it('should return "NaN" for a user with no sleep data', function() {
+        const nonExistentUser = { id: 999 };
+        const averageSleepQuality = getAverageSleepQuality(nonExistentUser);
+        expect(averageSleepQuality).to.equal('NaN');
+    });
+    
+
+});
+
+describe('getMostRecentSleepQuality()', () => {
+
+    it('should return the most recent sleep data entry for a user', function() {
+        const userAFK = account.users[2];
+        const mostRecentSleepHours = getMostRecentSleepQuality(userAFK);
+        expect(mostRecentSleepHours).to.be.a('number');
+        const expectedAverage = (4.2)
+        expect(mostRecentSleepHours).to.equal(expectedAverage);
+    });
+    
+    it('should return the most recent sleep data entry for a different user', function() {
+        const user000 = account.users[6];
+        const mostRecentSleepHours = getMostRecentSleepQuality(user000);
+        const expectedAverage = (3.4)
+        expect(mostRecentSleepHours).to.equal(expectedAverage);
+    });
+
+
+    it('should return "NaN" for a user with no sleep data', function() {
+        const nonExistentUser = { id: 999 };
+        const averageSleepQuality = getAverageSleepQuality(nonExistentUser);
+        expect(averageSleepQuality).to.equal('NaN');
+    });
+    
+
+});
+
+describe('getWeeklySleepHours()', () => {
+
+    it('correctly extracts weekly sleep hours for a user', function() {
+        const selectedWeek = [
+          [
+            {"userID": 9, "date": "2023/03/24", "hoursSlept": 4.8, "sleepQuality": 2.5},
+            {"userID": 9, "date": "2023/03/25", "hoursSlept": 9.2, "sleepQuality": 4.8},
+            {"userID": 9, "date": "2023/03/26", "hoursSlept": 6.2, "sleepQuality": 2.5},
+            {"userID": 9, "date": "2023/03/27", "hoursSlept": 6.8, "sleepQuality": 2.8},
+            {"userID": 9, "date": "2023/03/28", "hoursSlept": 7.5, "sleepQuality": 2.3},
+            {"userID": 9, "date": "2023/03/29", "hoursSlept": 7.2, "sleepQuality": 3.2},
+            {"userID": 9, "date": "2023/03/30", "hoursSlept": 7.8, "sleepQuality": 3.8}
+          ]
+        ];
+        const expectedHours = [4.8, 9.2, 6.2, 6.8, 7.5, 7.2, 7.8];
+        const result = getWeeklySleepHours(selectedWeek);
+        expect(result).to.deep.equal(expectedHours);
+      });
+
+    it('returns an empty array if selectedWeek data is empty', function() {
+        const selectedWeek = [[]];
+        const result = getWeeklySleepHours(selectedWeek);
+        expect(result).to.be.an('array').that.is.empty;
+      });
+
+    it('handles incorrect data structure gracefully', function() {
+    const incorrectData = {}; 
+    expect(() => getWeeklySleepHours(incorrectData)).to.throw();
+    });
+
+});
+
+describe('getWeeklySleepQuality()', () => {
+
+    it('correctly extracts weekly sleep quality scores for a user', function() {
+      const selectedWeek = [
+        [
+          {"userID": 9, "date": "2023/03/24", "hoursSlept": 4.8, "sleepQuality": 2.5},
+          {"userID": 9, "date": "2023/03/25", "hoursSlept": 9.2, "sleepQuality": 4.8},
+          {"userID": 9, "date": "2023/03/26", "hoursSlept": 6.2, "sleepQuality": 2.5},
+          {"userID": 9, "date": "2023/03/27", "hoursSlept": 6.8, "sleepQuality": 2.8},
+          {"userID": 9, "date": "2023/03/28", "hoursSlept": 7.5, "sleepQuality": 2.3},
+          {"userID": 9, "date": "2023/03/29", "hoursSlept": 7.2, "sleepQuality": 3.2},
+          {"userID": 9, "date": "2023/03/30", "hoursSlept": 7.8, "sleepQuality": 3.8}
+        ]
+      ];
+      const expectedQualityScores = [2.5, 4.8, 2.5, 2.8, 2.3, 3.2, 3.8];
+      const result = getWeeklySleepQuality(selectedWeek);
+      expect(result).to.deep.equal(expectedQualityScores);
+    });
+  
+    it('returns an empty array if selectedWeek data is empty', function() {
+      const selectedWeek = [[]];
+      const result = getWeeklySleepQuality(selectedWeek);
+      expect(result).to.be.an('array').that.is.empty;
+    });
+
+    it('handles incorrect data structure gracefully', function() {
+        const incorrectData = {}; 
+        expect(() => getWeeklySleepHours(incorrectData)).to.throw();
+        });
+  
+  });
\ No newline at end of file
diff --git a/test/users-test.js b/test/users-test.js
new file mode 100644
index 000000000..b3f9745f8
--- /dev/null
+++ b/test/users-test.js
@@ -0,0 +1,101 @@
+import { expect } from 'chai';
+import { 
+    generateRandomUser, 
+    getAccountFriends,
+    getAverageStepGoal,
+} from '../src/users';
+import account from '../src/data/users-test-data'
+
+describe('generateRandomUser()', () => {
+    var people = 
+    { users: [
+        {
+        "id": 14,
+        "name": "Elmira Walsh",
+        "address": "575 Robel Flats, Hagenesborough NE 51196-7863",
+        },
+        {
+        "id": 2,
+        "name": "Tyreek VonRueden",
+        "address": "623 Koelpin Skyway, Lake Luigichester MN 77576-1678",
+        },
+        {
+        "id": 3,
+        "name": "Colt Rohan",
+        "address": "48010 Balistreri Harbor, Cleobury IN 43317",
+        }
+    ]}
+   
+    it('should be an object', function () {
+        let person = generateRandomUser(account)
+        expect(person).to.be.an('object');
+    });
+
+    it('should return a user within the users array', () => {
+        const usersSet = new Set(account.users);
+        const user = generateRandomUser(people);
+        expect(usersSet.has(user)).to.be.true;
+      });
+    
+
+    it('should probabilistically return different users over multiple invocations', () => {
+        const sampleSize = 3;
+        const results = new Set();
+    
+        for (let i = 0; i < sampleSize; i++) {
+          const user = generateRandomUser(people);
+          results.add(user);
+        }
+    
+        expect(results.size).to.be.greaterThan(1);
+    });
+
+});
+
+describe('getAccountFriends()', () => {
+
+    it('returns the names of friends for a given user, separated by " - "', function() {
+      const user = account.users.find(u => u.id === 1);
+      const result = getAccountFriends(user);
+
+      expect(result).to.equal('Adelaide Smith - Olivia Garcia');
+    });
+  
+    it('returns an empty string for a user with no matching friends in the list', function() {
+      const userWithNoFriends = {
+        "id": 999,
+        "name": "John Doe",
+        "friends": [9999] 
+      };
+      const result = getAccountFriends(userWithNoFriends);
+      expect(result).to.equal('');
+    });
+  
+  });
+
+// ----- * Steps * ----- //
+
+describe('getAverageStepGoal()', () => {
+    
+    it('should return the daily step goal for a single user', () => {
+        const account = {
+        users: [{ dailyStepGoal: 10000 }]
+        };
+        expect(getAverageStepGoal(account)).to.equal(10000);
+    });
+    
+    it('should calculate the average step goal for multiple users', () => {
+        const account = {
+          users: [{ dailyStepGoal: 8000 }, { dailyStepGoal: 10000 }]
+        };
+        expect(getAverageStepGoal(account)).to.equal(9000);
+    });
+
+    it('should handle large numbers correctly', () => {
+        const account = {
+          users: [{ dailyStepGoal: 1000000 }, { dailyStepGoal: 2000000 }]
+        };
+        expect(getAverageStepGoal(account)).to.equal(1500000);
+      });
+
+});
\ No newline at end of file